swarm: release v0.4.3 (#1602 )

* swarm: 0.4.3 release notes * swarm: 0.4.3 stable version * swarm: 0.4.3 release notes - fix
network/retrieve: add bzz-retrieve protocol (#1589 )
2019-07-25 13:08:29 +02:00 · 2019-07-25 10:53:46 +02:00 · 2019-07-24 17:00:13 +02:00 · 2019-07-19 13:35:11 +02:00 · 2019-07-18 18:49:20 +02:00 · 2019-07-17 16:21:50 +02:00
3682 changed files with 652069 additions and 246798 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -1,5 +1 @@
-**/*_test.go
-
-build/_workspace
-build/_bin
-tests/testdata
+.github
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -1,23 +1 @@
-# Lines starting with '#' are comments.
-# Each line is a file pattern followed by one or more owners.
-
-accounts/usbwallet              @karalabe
-accounts/scwallet               @gballet
-accounts/abi                    @gballet
-cmd/clef                        @holiman
-cmd/puppeth                     @karalabe
-consensus                       @karalabe
-core/                           @karalabe @holiman @rjl493456442
-dashboard/                      @kurkomisi
-eth/                            @karalabe @holiman @rjl493456442
-graphql/                        @gballet
-les/                            @zsfelfoldi @rjl493456442
-light/                          @zsfelfoldi @rjl493456442
-mobile/                         @karalabe @ligi
-p2p/                            @fjl @zsfelfoldi
-rpc/                            @fjl @holiman
-p2p/simulations                 @zelig @nonsense @janos @justelad
-p2p/protocols                   @zelig @nonsense @janos @justelad
-p2p/testing                     @zelig @nonsense @janos @justelad
-signer/                         @holiman
-whisper/                        @gballet @gluk256
+# To be defined
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@ -1,40 +1,20 @@
-# Contributing
+## Contributing

-Thank you for considering to help out with the source code! We welcome 
-contributions from anyone on the internet, and are grateful for even the 
-smallest of fixes!
+Thank you for considering to help out with the source code! We welcome contributions from
+anyone on the internet, and are grateful for even the smallest of fixes!

-If you'd like to contribute to go-ethereum, please fork, fix, commit and send a 
-pull request for the maintainers to review and merge into the main code base. If
-you wish to submit more complex changes though, please check up with the core 
-devs first on [our gitter channel](https://gitter.im/ethereum/go-ethereum) to 
-ensure those changes are in line with the general philosophy of the project 
-and/or get some early feedback which can make both your efforts much lighter as
-well as our review and merge procedures quick and simple.
-
-## Coding guidelines
+If you'd like to contribute to Swarm, please fork, fix, commit and send a pull request
+for the maintainers to review and merge into the main code base. If you wish to submit more
+complex changes though, please check up with the core devs first on [our Swarm gitter channel](https://gitter.im/ethersphere/orange-lounge)
+to ensure those changes are in line with the general philosophy of the project and/or get some
+early feedback which can make both your efforts much lighter as well as our review and merge
+procedures quick and simple.

 Please make sure your contributions adhere to our coding guidelines:

- * Code must adhere to the official Go 
-[formatting](https://golang.org/doc/effective_go.html#formatting) guidelines 
-(i.e. uses [gofmt](https://golang.org/cmd/gofmt/)).
- * Code must be documented adhering to the official Go 
-[commentary](https://golang.org/doc/effective_go.html#commentary) guidelines.
+ * Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting) guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)).
+ * Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines.
 * Pull requests need to be based on and opened against the `master` branch.
+ * [Code review guidelines](https://github.com/ethersphere/swarm/blob/master/docs/Code-Review-Guidelines.md).
 * Commit messages should be prefixed with the package(s) they modify.
-   * E.g. "eth, rpc: make trace configs optional"
-
-## Can I have feature X
-
-Before you submit a feature request, please check and make sure that it isn't 
-possible through some other means. The JavaScript-enabled console is a powerful 
-feature in the right hands. Please check our 
-[Wiki page](https://github.com/ethereum/go-ethereum/wiki) for more info
-and help.
-
-## Configuration, dependencies, and tests
-
-Please see the [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
-for more details on configuring your environment, managing project dependencies
-and testing procedures.
+   * E.g. "fuse: ignore default manifest entry"
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,12 +1,8 @@
-Hi there,
-
-please note that this is an issue tracker reserved for bug reports and feature requests.
-
-For general questions please use the gitter channel or the Ethereum stack exchange at https://ethereum.stackexchange.com.
+<!-- Thanks for filing an issue! Before hitting the button, please answer these questions. It's helpful to search the existing GitHub issues first. It's likely that another user has already reported the issue you're facing, or it's a known issue that we're already aware of. Please note that this is an issue tracker reserved for bug reports and feature requests. For general questions please use the gitter channel https://gitter.im/ethereum/swarm or the ethereum stack exchange at https://ethereum.stackexchange.com. -->

 #### System information

-Geth version: `geth version`
+Swarm version: `swarm version`
 OS & Version: Windows/Linux/OSX
 Commit hash : (if `develop`)

--- a/.gitmodules
+++ b/.gitmodules
@ -1,3 +0,0 @@
-[submodule "tests"]
-	path = tests/testdata
-	url = https://github.com/ethereum/tests
--- a/.mailmap
+++ b/.mailmap
@ -1,123 +0,0 @@
-Jeffrey Wilcke <jeffrey@ethereum.org>
-Jeffrey Wilcke <jeffrey@ethereum.org> <geffobscura@gmail.com>
-Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@obscura.com>
-Jeffrey Wilcke <jeffrey@ethereum.org> <obscuren@users.noreply.github.com>
-
-Viktor Trón <viktor.tron@gmail.com>
-
-Joseph Goulden <joegoulden@gmail.com>
-
-Nick Savers <nicksavers@gmail.com>
-
-Maran Hidskes <maran.hidskes@gmail.com>
-
-Taylor Gerring <taylor.gerring@gmail.com>
-Taylor Gerring <taylor.gerring@gmail.com> <taylor.gerring@ethereum.org>
-
-Bas van Kervel <bas@ethdev.com>
-Bas van Kervel <bas@ethdev.com> <basvankervel@ziggo.nl>
-Bas van Kervel <bas@ethdev.com> <basvankervel@gmail.com>
-Bas van Kervel <bas@ethdev.com> <bas-vk@users.noreply.github.com>
-
-Sven Ehlert <sven@ethdev.com>
-
-Vitalik Buterin <v@buterin.com>
-
-Marian Oancea <contact@siteshop.ro>
-
-Christoph Jentzsch <jentzsch.software@gmail.com>
-
-Heiko Hees <heiko@heiko.org>
-
-Alex Leverington <alex@ethdev.com>
-Alex Leverington <alex@ethdev.com> <subtly@users.noreply.github.com>
-
-Zsolt Felföldi <zsfelfoldi@gmail.com>
-
-Gavin Wood <i@gavwood.com>
-
-Martin Becze <mjbecze@gmail.com>
-Martin Becze <mjbecze@gmail.com> <wanderer@users.noreply.github.com>
-
-Dimitry Khokhlov <winsvega@mail.ru>
-
-Roman Mandeleil <roman.mandeleil@gmail.com>
-
-Alec Perseghin <aperseghin@gmail.com>
-
-Alon Muroch <alonmuroch@gmail.com>
-
-Arkadiy Paronyan <arkadiy@ethdev.com>
-
-Jae Kwon <jkwon.work@gmail.com>
-
-Aaron Kumavis <kumavis@users.noreply.github.com>
-
-Nick Dodson <silentcicero@outlook.com>
-
-Jason Carver <jacarver@linkedin.com>
-Jason Carver <jacarver@linkedin.com> <ut96caarrs@snkmail.com>
-
-Joseph Chow <ethereum@outlook.com>
-Joseph Chow <ethereum@outlook.com> ethers <TODO>
-
-Enrique Fynn <enriquefynn@gmail.com>
-
-Vincent G <caktux@gmail.com>
-
-RJ Catalano <catalanor0220@gmail.com>
-RJ Catalano <catalanor0220@gmail.com> <rj@erisindustries.com>
-
-Nchinda Nchinda <nchinda2@gmail.com>
-
-Aron Fischer <github@aron.guru> <homotopycolimit@users.noreply.github.com>
-
-Vlad Gluhovsky <gluk256@users.noreply.github.com>
-
-Ville Sundell <github@solarius.fi>
-
-Elliot Shepherd <elliot@identitii.com>
-
-Yohann Léon <sybiload@gmail.com>
-
-Gregg Dourgarian <greggd@tempworks.com>
-
-Casey Detrio <cdetrio@gmail.com>
-
-Jens Agerberg <github@agerberg.me>
-
-Nick Johnson <arachnid@notdot.net>
-
-Henning Diedrich <hd@eonblast.com>
-Henning Diedrich <hd@eonblast.com> Drake Burroughs <wildfyre@hotmail.com>
-
-Felix Lange <fjl@twurst.com>
-Felix Lange <fjl@twurst.com> <fjl@users.noreply.github.com>
-
-Максим Чусовлянов <mchusovlianov@gmail.com>
-
-Louis Holbrook <dev@holbrook.no>
-Louis Holbrook <dev@holbrook.no> <nolash@users.noreply.github.com>
-
-Thomas Bocek <tom@tomp2p.net>
-
-Victor Tran <vu.tran54@gmail.com>
-
-Justin Drake <drakefjustin@gmail.com>
-
-Frank Wang <eternnoir@gmail.com>
-
-Gary Rong <garyrong0905@gmail.com>
-
-Guillaume Nicolas <guin56@gmail.com>
-
-Sorin Neacsu <sorin.neacsu@gmail.com>
-Sorin Neacsu <sorin.neacsu@gmail.com> <sorin@users.noreply.github.com>
-
-Valentin Wüstholz <wuestholz@gmail.com>
-Valentin Wüstholz <wuestholz@gmail.com> <wuestholz@users.noreply.github.com>
-
-Armin Braun <me@obrown.io>
-
-Ernesto del Toro <ernesto.deltoro@gmail.com>
-Ernesto del Toro <ernesto.deltoro@gmail.com> <ernestodeltoro@users.noreply.github.com>
--- a/.readthedocs.yml
+++ b/.readthedocs.yml
@ -0,0 +1,14 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+sphinx:
+  configuration: docs/swarm-guide/contents/conf.py
+  builder: html
+
+python:
+  version: 3.7
+  install:
+    - requirements: docs/swarm-guide/requirements.txt
--- a/.travis.yml
+++ b/.travis.yml
@ -1,47 +1,36 @@
 language: go
-go_import_path: github.com/ethereum/go-ethereum
+go_import_path: github.com/ethersphere/swarm
 sudo: false
-jobs:
+branches:
+  only:
+    - master
+    - /v(\d+\.)(\d+\.)(\d)/
+matrix:
  include:
-        # This builder only tests code linters on latest version of Go
-    - stage: lint
-      os: linux
-      dist: xenial
-      go: 1.12.x
-      env:
-        - lint
-      git:
-        submodules: false # avoid cloning ethereum/tests
-      script:
-        - go run build/ci.go lint
-
-    - stage: build
-      os: linux
-      dist: xenial
-      go: 1.10.x
-      script:
-      - go run build/ci.go install
-      - go run build/ci.go test -coverage $TEST_PACKAGES
-
-    - stage: build
-      os: linux
-      dist: xenial
+    - os: linux
+      dist: trusty
+      sudo: required
      go: 1.11.x
      script:
+        - sudo modprobe fuse
+        - sudo chmod 666 /dev/fuse
+        - sudo chown root:$USER /etc/fuse.conf
        - go run build/ci.go install
        - go run build/ci.go test -coverage $TEST_PACKAGES

    # These are the latest Go versions.
-    - stage: build
-      os: linux
-      dist: xenial
+    - os: linux
+      dist: trusty
+      sudo: required
      go: 1.12.x
      script:
+        - sudo modprobe fuse
+        - sudo chmod 666 /dev/fuse
+        - sudo chown root:$USER /etc/fuse.conf
        - go run build/ci.go install
        - go run build/ci.go test -coverage $TEST_PACKAGES

-    - stage: build
-      os: osx
+    - os: osx
      go: 1.12.x
      script:
        - echo "Increase the maximum number of open file descriptors on macOS"
@ -56,16 +45,22 @@ jobs:
        - go run build/ci.go install
        - go run build/ci.go test -coverage $TEST_PACKAGES

+    # This builder only tests code linters on latest version of Go
+    - os: linux
+      dist: trusty
+      go: 1.12.x
+      env:
+        - lint
+      script:
+        - go run build/ci.go lint
+
    # This builder does the Ubuntu PPA upload
-    - stage: build
-      if: type = push
+    - if: type = push
      os: linux
-      dist: xenial
+      dist: trusty
      go: 1.12.x
      env:
        - ubuntu-ppa
-      git:
-        submodules: false # avoid cloning ethereum/tests
      addons:
        apt:
          packages:
@ -77,19 +72,16 @@ jobs:
            - python-paramiko
      script:
        - echo '|1|7SiYPr9xl3uctzovOTj4gMwAC1M=|t6ReES75Bo/PxlOPJ6/GsGbTrM0= ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA0aKz5UTUndYgIGG7dQBV+HaeuEZJ2xPHo2DS2iSKvUL4xNMSAY4UguNW+pX56nAQmZKIZZ8MaEvSj6zMEDiq6HFfn5JcTlM80UwlnyKe8B8p7Nk06PPQLrnmQt5fh0HmEcZx+JU9TZsfCHPnX7MNz4ELfZE6cFsclClrKim3BHUIGq//t93DllB+h4O9LHjEUsQ1Sr63irDLSutkLJD6RXchjROXkNirlcNVHH/jwLWR5RcYilNX7S5bIkK8NlWPjsn/8Ua5O7I9/YoE97PpO6i73DTGLh5H9JN/SITwCKBkgSDWUt61uPK3Y11Gty7o2lWsBjhBUm2Y38CBsoGmBw==' >> ~/.ssh/known_hosts
-        - go run build/ci.go debsrc -upload ethereum/ethereum -sftp-user geth-ci -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>"
+        - go run build/ci.go debsrc -upload ethereum/ethereum -sftp-user ethswarm -signer "Ethereum Swarm Linux Builder <swarm@ethereum.org>"

    # This builder does the Linux Azure uploads
-    - stage: build
-      if: type = push
+    - if: type = push
      os: linux
-      dist: xenial
+      dist: trusty
      sudo: required
      go: 1.12.x
      env:
        - azure-linux
-      git:
-        submodules: false # avoid cloning ethereum/tests
      addons:
        apt:
          packages:
@ -97,129 +89,66 @@ jobs:
      script:
        # Build for the primary platforms that Trusty can manage
        - go run build/ci.go install
-        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds
        - go run build/ci.go install -arch 386
-        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

        # Switch over GCC to cross compilation (breaks 386, hence why do it here only)
        - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-arm-linux-gnueabihf libc6-dev-armhf-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross
        - sudo ln -s /usr/include/asm-generic /usr/include/asm

        - GOARM=5 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc
-        - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds
        - GOARM=6 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc
-        - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds
        - GOARM=7 go run build/ci.go install -arch arm -cc arm-linux-gnueabihf-gcc
-        - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds
        - go run build/ci.go install -arch arm64 -cc aarch64-linux-gnu-gcc
-        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

    # This builder does the Linux Azure MIPS xgo uploads
-    - stage: build
-      if: type = push
+    - if: type = push
      os: linux
-      dist: xenial
+      dist: trusty
      services:
        - docker
      go: 1.12.x
      env:
        - azure-linux-mips
-      git:
-        submodules: false # avoid cloning ethereum/tests
      script:
        - go run build/ci.go xgo --alltools -- --targets=linux/mips --ldflags '-extldflags "-static"' -v
        - for bin in build/bin/*-linux-mips; do mv -f "${bin}" "${bin/-linux-mips/}"; done
-        - go run build/ci.go archive -arch mips -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mips -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

        - go run build/ci.go xgo --alltools -- --targets=linux/mipsle --ldflags '-extldflags "-static"' -v
        - for bin in build/bin/*-linux-mipsle; do mv -f "${bin}" "${bin/-linux-mipsle/}"; done
-        - go run build/ci.go archive -arch mipsle -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mipsle -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

        - go run build/ci.go xgo --alltools -- --targets=linux/mips64 --ldflags '-extldflags "-static"' -v
        - for bin in build/bin/*-linux-mips64; do mv -f "${bin}" "${bin/-linux-mips64/}"; done
-        - go run build/ci.go archive -arch mips64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mips64 -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

        - go run build/ci.go xgo --alltools -- --targets=linux/mips64le --ldflags '-extldflags "-static"' -v
        - for bin in build/bin/*-linux-mips64le; do mv -f "${bin}" "${bin/-linux-mips64le/}"; done
-        - go run build/ci.go archive -arch mips64le -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds
-
-    # This builder does the Android Maven and Azure uploads
-    - stage: build
-      if: type = push
-      os: linux
-      dist: xenial
-      addons:
-        apt:
-          packages:
-            - oracle-java8-installer
-            - oracle-java8-set-default
-      language: android
-      android:
-        components:
-          - platform-tools
-          - tools
-          - android-15
-          - android-19
-          - android-24
-      env:
-        - azure-android
-        - maven-android
-      git:
-        submodules: false # avoid cloning ethereum/tests
-      before_install:
-        - curl https://dl.google.com/go/go1.12.linux-amd64.tar.gz | tar -xz
-        - export PATH=`pwd`/go/bin:$PATH
-        - export GOROOT=`pwd`/go
-        - export GOPATH=$HOME/go
-      script:
-        # Build the Android archive and upload it to Maven Central and Azure
-        - curl https://dl.google.com/android/repository/android-ndk-r19b-linux-x86_64.zip -o android-ndk-r19b.zip
-        - unzip -q android-ndk-r19b.zip && rm android-ndk-r19b.zip
-        - mv android-ndk-r19b $ANDROID_HOME/ndk-bundle
-
-        - mkdir -p $GOPATH/src/github.com/ethereum
-        - ln -s `pwd` $GOPATH/src/github.com/ethereum/go-ethereum
-        - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/builds
+        - go run build/ci.go archive -arch mips64le -type tar -signer LINUX_SIGNING_KEY -upload ethswarm/builds

    # This builder does the OSX Azure, iOS CocoaPods and iOS Azure uploads
-    - stage: build
-      if: type = push
+    - if: type = push
      os: osx
      go: 1.12.x
      env:
        - azure-osx
-        - azure-ios
-        - cocoapods-ios
-      git:
-        submodules: false # avoid cloning ethereum/tests
      script:
        - go run build/ci.go install
-        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds
+        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload ethswarm/builds

-        # Build the iOS framework and upload it to CocoaPods and Azure
-        - gem uninstall cocoapods -a -x
-        - gem install cocoapods
-
-        - mv ~/.cocoapods/repos/master ~/.cocoapods/repos/master.bak
-        - sed -i '.bak' 's/repo.join/!repo.join/g' $(dirname `gem which cocoapods`)/cocoapods/sources_manager.rb
-        - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then git clone --depth=1 https://github.com/CocoaPods/Specs.git ~/.cocoapods/repos/master && pod setup --verbose; fi
-
-        - xctool -version
-        - xcrun simctl list
-
-        # Workaround for https://github.com/golang/go/issues/23749
-        - export CGO_CFLAGS_ALLOW='-fmodules|-fblocks|-fobjc-arc'
-        - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds

    # This builder does the Azure archive purges to avoid accumulating junk
-    - stage: build
-      if: type = cron
+    - if: type = cron
      os: linux
-      dist: xenial
+      dist: trusty
      go: 1.12.x
      env:
        - azure-purge
-      git:
-        submodules: false # avoid cloning ethereum/tests
      script:
-        - go run build/ci.go purge -store gethstore/builds -days 14
+        - go run build/ci.go purge -store ethswarm/builds -days 14
--- a/402
+++ b/402
@ -1,369 +1,35 @@
-# This is the official list of go-ethereum authors for copyright purposes.
+# Core team members

-a e r t h <aerth@users.noreply.github.com>
-Abel Nieto <abel.nieto90@gmail.com>
-Abel Nieto <anietoro@uwaterloo.ca>
-Adam Babik <a.babik@designfortress.com>
-Aditya <adityasripal@gmail.com>
-Adrià Cidre <adria.cidre@gmail.com>
-Afri Schoedon <5chdn@users.noreply.github.com>
-Agustin Armellini Fischer <armellini13@gmail.com>
-Airead <fgh1987168@gmail.com>
-Alan Chen <alanchchen@users.noreply.github.com>
-Alejandro Isaza <alejandro.isaza@gmail.com>
-Ales Katona <ales@coinbase.com>
-Alex Leverington <alex@ethdev.com>
-Alex Wu <wuyiding@gmail.com>
-Alexandre Van de Sande <alex.vandesande@ethdev.com>
-Ali Hajimirza <Ali92hm@users.noreply.github.com>
-am2rican5 <am2rican5@gmail.com>
-Andrea Franz <andrea@gravityblast.com>
-Andrey Petrov <andrey.petrov@shazow.net>
-Andrey Petrov <shazow@gmail.com>
-ANOTHEL <anothel1@naver.com>
-Antoine Rondelet <rondelet.antoine@gmail.com>
-Anton Evangelatov <anton.evangelatov@gmail.com>
-Antonio Salazar Cardozo <savedfastcool@gmail.com>
-Arba Sasmoyo <arba.sasmoyo@gmail.com>
-Armani Ferrante <armaniferrante@berkeley.edu>
-Armin Braun <me@obrown.io>
-Aron Fischer <github@aron.guru>
-atsushi-ishibashi <atsushi.ishibashi@finatext.com>
-ayeowch <ayeowch@gmail.com>
-b00ris <b00ris@mail.ru>
-bailantaotao <Edwin@maicoin.com>
-baizhenxuan <nkbai@163.com>
-Balint Gabor <balint.g@gmail.com>
-Bas van Kervel <bas@ethdev.com>
-Benjamin Brent <benjamin@benjaminbrent.com>
-benma <mbencun@gmail.com>
-Benoit Verkindt <benoit.verkindt@gmail.com>
-bloonfield <bloonfield@163.com>
-Bo <bohende@gmail.com>
-Bo Ye <boy.e.computer.1982@outlook.com>
-Bob Glickstein <bobg@users.noreply.github.com>
-Brent <bmperrea@gmail.com>
-Brian Schroeder <bts@gmail.com>
-Bruno Škvorc <bruno@skvorc.me>
-C. Brown <hackdom@majoolr.io>
-Caesar Chad <BLUE.WEB.GEEK@gmail.com>
-Casey Detrio <cdetrio@gmail.com>
-CDsigma <cdsigma271@gmail.com>
-changhong <changhong.yu@shanbay.com>
-Chase Wright <mysticryuujin@gmail.com>
-Chen Quan <terasum@163.com>
-chenyufeng <yufengcode@gmail.com>
-Christian Muehlhaeuser <muesli@gmail.com>
-Christoph Jentzsch <jentzsch.software@gmail.com>
-cong <ackratos@users.noreply.github.com>
-Corey Lin <514971757@qq.com>
-cpusoft <cpusoft@live.com>
-Crispin Flowerday <crispin@bitso.com>
-croath <croathliu@gmail.com>
-cui <523516579@qq.com>
-Dan Kinsley <dan@joincivil.com>
-Daniel A. Nagy <nagy.da@gmail.com>
-Daniel Sloof <goapsychadelic@gmail.com>
-Darrel Herbst <dherbst@gmail.com>
-Dave Appleton <calistralabs@gmail.com>
-Dave McGregor <dave.s.mcgregor@gmail.com>
-David Huie <dahuie@gmail.com>
-Derek Gottfrid <derek@codecubed.com>
-Diego Siqueira <DiSiqueira@users.noreply.github.com>
-Diep Pham <mrfavadi@gmail.com>
-dipingxian2 <39109351+dipingxian2@users.noreply.github.com>
-dm4 <sunrisedm4@gmail.com>
-Dmitrij Koniajev <dimchansky@gmail.com>
-Dmitry Shulyak <yashulyak@gmail.com>
-Domino Valdano <dominoplural@gmail.com>
-Domino Valdano <jeff@okcupid.com>
-Dragan Milic <dragan@netice9.com>
-dragonvslinux <35779158+dragononcrypto@users.noreply.github.com>
-Egon Elbre <egonelbre@gmail.com>
-Elad <theman@elad.im>
-Eli <elihanover@yahoo.com>
-Elias Naur <elias.naur@gmail.com>
-Elliot Shepherd <elliot@identitii.com>
-Emil <mursalimovemeel@gmail.com>
-emile <emile@users.noreply.github.com>
-Enrique Fynn <enriquefynn@gmail.com>
-Enrique Fynn <me@enriquefynn.com>
-EOS Classic <info@eos-classic.io>
-Erichin <erichinbato@gmail.com>
-Ernesto del Toro <ernesto.deltoro@gmail.com>
-Ethan Buchman <ethan@coinculture.info>
-ethersphere <thesw@rm.eth>
-Eugene Valeyev <evgen.povt@gmail.com>
-Evangelos Pappas <epappas@evalonlabs.com>
-Evgeny <awesome.observer@yandex.com>
-Evgeny Danilenko <6655321@bk.ru>
-evgk <evgeniy.kamyshev@gmail.com>
-Fabian Vogelsteller <fabian@frozeman.de>
-Fabio Barone <fabio.barone.co@gmail.com>
-Fabio Berger <fabioberger1991@gmail.com>
-FaceHo <facehoshi@gmail.com>
-Felix Lange <fjl@twurst.com>
-Ferenc Szabo <frncmx@gmail.com>
-ferhat elmas <elmas.ferhat@gmail.com>
-Fiisio <liangcszzu@163.com>
-Frank Szendzielarz <33515470+FrankSzendzielarz@users.noreply.github.com>
-Frank Wang <eternnoir@gmail.com>
-Franklin <mr_franklin@126.com>
-Furkan KAMACI <furkankamaci@gmail.com>
-GagziW <leon.stanko@rwth-aachen.de>
-Gary Rong <garyrong0905@gmail.com>
-George Ornbo <george@shapeshed.com>
-Gregg Dourgarian <greggd@tempworks.com>
-Guilherme Salgado <gsalgado@gmail.com>
-Guillaume Ballet <gballet@gmail.com>
-Guillaume Nicolas <guin56@gmail.com>
-GuiltyMorishita <morilliantblue@gmail.com>
-Gus <yo@soygus.com>
-Gustav Simonsson <gustav.simonsson@gmail.com>
-Gísli Kristjánsson <gislik@hamstur.is>
-Ha ĐANG <dvietha@gmail.com>
-HackyMiner <hackyminer@gmail.com>
-hadv <dvietha@gmail.com>
-Hao Bryan Cheng <haobcheng@gmail.com>
-HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
-Henning Diedrich <hd@eonblast.com>
-holisticode <holistic.computing@gmail.com>
-Hongbin Mao <hello2mao@gmail.com>
-Hsien-Tang Kao <htkao@pm.me>
-Husam Ibrahim <39692071+HusamIbrahim@users.noreply.github.com>
-hydai <z54981220@gmail.com>
-Hyung-Kyu Hqueue Choi <hyungkyu.choi@gmail.com>
-Ian Macalinao <me@ian.pw>
-Ian Norden <iannordenn@gmail.com>
-Isidoro Ghezzi <isidoro.ghezzi@icloud.com>
-Iskander (Alex) Sharipov <quasilyte@gmail.com>
-Ivan Daniluk <ivan.daniluk@gmail.com>
-Ivo Georgiev <ivo@strem.io>
-Jae Kwon <jkwon.work@gmail.com>
-Jamie Pitts <james.pitts@gmail.com>
-Janos Guljas <janos@resenje.org>
-Janoš Guljaš <janos@users.noreply.github.com>
-Jason Carver <jacarver@linkedin.com>
-Javier Peletier <jm@epiclabs.io>
-Javier Peletier <jpeletier@users.noreply.github.com>
-Javier Sagredo <jasataco@gmail.com>
-Jay <codeholic.arena@gmail.com>
-Jay Guo <guojiannan1101@gmail.com>
-Jaynti Kanani <jdkanani@gmail.com>
-Jeff Prestes <jeffprestes@gmail.com>
-Jeff R. Allen <jra@nella.org>
-Jeffery Robert Walsh <rlxrlps@gmail.com>
-Jeffrey Wilcke <jeffrey@ethereum.org>
-Jens Agerberg <github@agerberg.me>
-Jeremy McNevin <jeremy.mcnevin@optum.com>
-Jeremy Schlatter <jeremy.schlatter@gmail.com>
-Jerzy Lasyk <jerzylasyk@gmail.com>
-Jia Chenhui <jiachenhui1989@gmail.com>
-Jim McDonald <Jim@mcdee.net>
-jkcomment <jkcomment@gmail.com>
-Joel Burget <joelburget@gmail.com>
-John C. Vernaleo <john@netpurgatory.com>
-Johns Beharry <johns@peakshift.com>
-Jonas <felberj@users.noreply.github.com>
-Jonathan Brown <jbrown@bluedroplet.com>
-JoranHonig <JoranHonig@users.noreply.github.com>
-Jordan Krage <jmank88@gmail.com>
-Joseph Chow <ethereum@outlook.com>
-jtakalai <juuso.takalainen@streamr.com>
-JU HYEONG PARK <dkdkajej@gmail.com>
-Justin Clark-Casey <justincc@justincc.org>
-Justin Drake <drakefjustin@gmail.com>
-jwasinger <j-wasinger@hotmail.com>
-ken10100147 <sunhongping@kanjian.com>
-Kenji Siu <kenji@isuntv.com>
-Kenso Trabing <kenso.trabing@bloomwebsite.com>
-Kenso Trabing <ktrabing@acm.org>
-Kevin <denk.kevin@web.de>
-kevin.xu <cming.xu@gmail.com>
-kiel barry <kiel.j.barry@gmail.com>
-kimmylin <30611210+kimmylin@users.noreply.github.com>
-Kitten King <53072918+kittenking@users.noreply.github.com>
-knarfeh <hejun1874@gmail.com>
-Kobi Gurkan <kobigurk@gmail.com>
-Konrad Feldmeier <konrad@brainbot.com>
-Kris Shinn <raggamuffin.music@gmail.com>
-Kurkó Mihály <kurkomisi@users.noreply.github.com>
-Kushagra Sharma <ksharm01@gmail.com>
-Kwuaint <34888408+kwuaint@users.noreply.github.com>
-Kyuntae Ethan Kim <ethan.kyuntae.kim@gmail.com>
-ledgerwatch <akhounov@gmail.com>
-Lefteris Karapetsas <lefteris@refu.co>
-Leif Jurvetson <leijurv@gmail.com>
-Leo Shklovskii <leo@thermopylae.net>
-LeoLiao <leofantast@gmail.com>
-Lewis Marshall <lewis@lmars.net>
-lhendre <lhendre2@gmail.com>
-Liang Ma <liangma.ul@gmail.com>
-Liang Ma <liangma@liangbit.com>
-Liang ZOU <liang.d.zou@gmail.com>
-libotony <liboliqi@gmail.com>
-ligi <ligi@ligi.de>
-Lio李欧 <lionello@users.noreply.github.com>
-Lorenzo Manacorda <lorenzo@kinvolk.io>
-Louis Holbrook <dev@holbrook.no>
-Luca Zeug <luclu@users.noreply.github.com>
-Magicking <s@6120.eu>
-manlio <manlio.poltronieri@gmail.com>
-Maran Hidskes <maran.hidskes@gmail.com>
-Marek Kotewicz <marek.kotewicz@gmail.com>
-Marius van der Wijden <m.vanderwijden@live.de>
-Mark <markya0616@gmail.com>
-Mark Rushakoff <mark.rushakoff@gmail.com>
-mark.lin <mark@maicoin.com>
-Martin Alex Philip Dawson <u1356770@gmail.com>
-Martin Holst Swende <martin@swende.se>
-Martin Klepsch <martinklepsch@googlemail.com>
-Mats Julian Olsen <mats@plysjbyen.net>
-Matt K <1036969+mkrump@users.noreply.github.com>
-Matthew Di Ferrante <mattdf@users.noreply.github.com>
-Matthew Halpern <matthalp@gmail.com>
-Matthew Halpern <matthalp@google.com>
-Matthew Wampler-Doty <matthew.wampler.doty@gmail.com>
-Max Sistemich <mafrasi2@googlemail.com>
-Maximilian Meister <mmeister@suse.de>
-Micah Zoltu <micah@zoltu.net>
-Michael Ruminer <michael.ruminer+github@gmail.com>
-Miguel Mota <miguelmota2@gmail.com>
-Miya Chen <miyatlchen@gmail.com>
-Mohanson <mohanson@outlook.com>
-mr_franklin <mr_franklin@126.com>
-Mymskmkt <1847234666@qq.com>
-Nalin Bhardwaj <nalinbhardwaj@nibnalin.me>
-Nchinda Nchinda <nchinda2@gmail.com>
-necaremus <necaremus@gmail.com>
-needkane <604476380@qq.com>
-Nguyen Kien Trung <trung.n.k@gmail.com>
-Nguyen Sy Thanh Son <thanhson1085@gmail.com>
-Nick Dodson <silentcicero@outlook.com>
-Nick Johnson <arachnid@notdot.net>
-Nicolas Guillaume <gunicolas@sqli.com>
-Nilesh Trivedi <nilesh@hypertrack.io>
-Nimrod Gutman <nimrod.gutman@gmail.com>
-njupt-moon <1015041018@njupt.edu.cn>
-nkbai <nkbai@163.com>
-nobody <ddean2009@163.com>
-Noman <noman@noman.land>
-Oleg Kovalov <iamolegkovalov@gmail.com>
-Oli Bye <olibye@users.noreply.github.com>
-Osuke <arget-fee.free.dgm@hotmail.co.jp>
-Paul Berg <hello@paulrberg.com>
-Paul Litvak <litvakpol@012.net.il>
-Paulo L F Casaretto <pcasaretto@gmail.com>
-Paweł Bylica <chfast@gmail.com>
-Pedro Pombeiro <PombeirP@users.noreply.github.com>
-Peter Broadhurst <peter@themumbles.net>
-Peter Pratscher <pratscher@gmail.com>
-Petr Mikusek <petr@mikusek.info>
-Philip Schlump <pschlump@gmail.com>
-Pierre Neter <pierreneter@gmail.com>
-PilkyuJung <anothel1@naver.com>
-protolambda <proto@protolambda.com>
-Péter Szilágyi <peterke@gmail.com>
-qd-ethan <31876119+qdgogogo@users.noreply.github.com>
-Raghav Sood <raghavsood@gmail.com>
-Ralph Caraveo <deckarep@gmail.com>
-Ralph Caraveo III <deckarep@gmail.com>
-Ramesh Nair <ram@hiddentao.com>
-reinerRubin <tolstov.georgij@gmail.com>
-rhaps107 <dod-source@yandex.ru>
-Ricardo Catalinas Jiménez <r@untroubled.be>
-Ricardo Domingos <ricardohsd@gmail.com>
-Richard Hart <richardhart92@gmail.com>
-RJ Catalano <catalanor0220@gmail.com>
-Rob <robert@rojotek.com>
-Rob Mulholand <rmulholand@8thlight.com>
-Robert Zaremba <robert.zaremba@scale-it.pl>
-Roc Yu <rociiu0112@gmail.com>
-Runchao Han <elvisage941102@gmail.com>
-Russ Cox <rsc@golang.org>
-Ryan Schneider <ryanleeschneider@gmail.com>
-Rémy Roy <remyroy@remyroy.com>
-S. Matthew English <s-matthew-english@users.noreply.github.com>
-salanfe <salanfe@users.noreply.github.com>
-Samuel Marks <samuelmarks@gmail.com>
-Sarlor <kinsleer@outlook.com>
-Sasuke1964 <neilperry1964@gmail.com>
-Saulius Grigaitis <saulius@necolt.com>
-Sean <darcys22@gmail.com>
-Sheldon <11510383@mail.sustc.edu.cn>
-Sheldon <374662347@qq.com>
-Shintaro Kaneko <kaneshin0120@gmail.com>
-Shuai Qi <qishuai231@gmail.com>
-Shunsuke Watanabe <ww.shunsuke@gmail.com>
-silence <wangsai.silence@qq.com>
-Simon Jentzsch <simon@slock.it>
-slumber1122 <slumber1122@gmail.com>
-Smilenator <yurivanenko@yandex.ru>
-Sorin Neacsu <sorin.neacsu@gmail.com>
-Stein Dekker <dekker.stein@gmail.com>
-Steve Gattuso <steve@stevegattuso.me>
-Steve Ruckdashel <steve.ruckdashel@gmail.com>
-Steve Waldman <swaldman@mchange.com>
-Steven Roose <stevenroose@gmail.com>
-stompesi <stompesi@gmail.com>
-stormpang <jialinpeng@vip.qq.com>
-sunxiaojun2014 <sunxiaojun-xy@360.cn>
-tamirms <tamir@trello.com>
-Taylor Gerring <taylor.gerring@gmail.com>
-TColl <38299499+TColl@users.noreply.github.com>
-terasum <terasum@163.com>
-Thomas Bocek <tom@tomp2p.net>
-thomasmodeneis <thomas.modeneis@gmail.com>
-thumb8432 <thumb8432@gmail.com>
-Ti Zhou <tizhou1986@gmail.com>
-Tosh Camille <tochecamille@gmail.com>
-tsarpaul <Litvakpol@012.net.il>
-tzapu <alex@tzapu.com>
-ult-bobonovski <alex@ultiledger.io>
-Valentin Wüstholz <wuestholz@gmail.com>
-Vedhavyas Singareddi <vedhavyas.singareddi@gmail.com>
-Victor Farazdagi <simple.square@gmail.com>
-Victor Tran <vu.tran54@gmail.com>
-Vie <yangchenzhong@gmail.com>
-Viktor Trón <viktor.tron@gmail.com>
-Ville Sundell <github@solarius.fi>
-vim88 <vim88vim88@gmail.com>
-Vincent G <caktux@gmail.com>
-Vincent Serpoul <vincent@serpoul.com>
-Vitalik Buterin <v@buterin.com>
-Vitaly Bogdanov <vsbogd@gmail.com>
-Vitaly V <vvelikodny@gmail.com>
-Vivek Anand <vivekanand1101@users.noreply.github.com>
-Vlad <gluk256@gmail.com>
-Vlad Bokov <razum2um@mail.ru>
-Vlad Gluhovsky <gluk256@users.noreply.github.com>
-weimumu <934657014@qq.com>
-Wenbiao Zheng <delweng@gmail.com>
-William Setzer <bootstrapsetzer@gmail.com>
-williambannas <wrschwartz@wpi.edu>
-Wuxiang <wuxiangzhou2010@gmail.com>
-xiekeyang <xiekeyang@users.noreply.github.com>
-xincaosu <xincaosu@126.com>
-yahtoo <yahtoo.ma@gmail.com>
-YaoZengzeng <yaozengzeng@zju.edu.cn>
-YH-Zhou <yanhong.zhou05@gmail.com>
-Yohann Léon <sybiload@gmail.com>
-Yoichi Hirai <i@yoichihirai.com>
-Yondon Fu <yondon.fu@gmail.com>
-YOSHIDA Masanori <masanori.yoshida@gmail.com>
-yoza <yoza.is12s@gmail.com>
-Yusup <awklsgrep@gmail.com>
-Zach <zach.ramsay@gmail.com>
-zah <zahary@gmail.com>
-Zahoor Mohamed <zahoor@zahoor.in>
-Zak Cole <zak@beattiecole.com>
-zer0to0ne <36526113+zer0to0ne@users.noreply.github.com>
-Zhenguo Niu <Niu.ZGlinux@gmail.com>
-Zoe Nolan <github@zoenolan.org>
-Zsolt Felföldi <zsfelfoldi@gmail.com>
-Łukasz Kurowski <crackcomm@users.noreply.github.com>
-ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com>
-Максим Чусовлянов <mchusovlianov@gmail.com>
-大彬 <hz_stb@163.com>
-贺鹏飞 <hpf@hackerful.cn>
-유용환 <33824408+eric-yoo@users.noreply.github.com>
+Viktor Trón - @zelig
+Louis Holbrook - @nolash
+Lewis Marshall - @lmars
+Anton Evangelatov - @nonsense
+Janoš Guljaš - @janos
+Balint Gabor - @gbalint
+Elad Nachmias - @justelad
+Daniel A. Nagy - @nagydani
+Aron Fischer - @homotopycolimit
+Fabio Barone - @holisticode
+Zahoor Mohamed - @jmozah
+Zsolt Felföldi - @zsfelfoldi
+
+# External contributors
+
+Kiel Barry
+Gary Rong 
+Jared Wasinger 
+Leon Stanko
+Javier Peletier [epiclabs.io]
+Bartek Borkowski [tungsten-labs.com]
+Shane Howley [mainframe.com]
+Doug Leonard [mainframe.com]
+Ivan Daniluk [status.im]
+Felix Lange [EF]
+Martin Holst Swende [EF]
+Guillaume Ballet [EF]
+ligi [EF]
+Christopher Dro [blick-labs.com]
+Sergii Bomko [ledgerleopard.com]
+Domino Valdano 
+Rafael Matias 
+Coogan Brennan
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,83 @@
+## v0.4.3 (July 25, 2019)
+
+### Notes
+
+- **Docker users:** The `$PASSWORD` and `$DATADIR` environment variables are not supported anymore since this release. From now on you should mount the password or data dirctories as a volume. For example:
+  ```bash
+  $ docker run -it -v $PWD/hostdata:/data \
+                   -v $PWD/password:/password \
+                   ethersphere/swarm:0.4.3 \
+                     --datadir /data \
+                     --password /password
+  ```
+
+### Bug fixes and improvements
+
+* [#1586](https://github.com/ethersphere/swarm/pull/1586): network: structured output for kademlia table
+* [#1582](https://github.com/ethersphere/swarm/pull/1582): client: add bzz client, update smoke tests
+* [#1578](https://github.com/ethersphere/swarm/pull/1578): swarm-smoke: fix check max prox hosts for pull/push sync modes
+* [#1557](https://github.com/ethersphere/swarm/pull/1557): cmd/swarm: allow using a network interface by name for nat purposes
+* [#1534](https://github.com/ethersphere/swarm/pull/1534): api, network: count chunk deliveries per peer
+* [#1537](https://github.com/ethersphere/swarm/pull/1537): swarm: fix bzz_info.port when using dynamic port allocation
+* [#1531](https://github.com/ethersphere/swarm/pull/1531): cmd/swarm: make bzzaccount flag optional and add bzzkeyhex flag
+* [#1536](https://github.com/ethersphere/swarm/pull/1536): cmd/swarm: use only one function to parse flags
+* [#1530](https://github.com/ethersphere/swarm/pull/1530): network/bitvector: Multibit set/unset + string rep
+* [#1555](https://github.com/ethersphere/swarm/pull/1555): PoC: Network simulation framework
+
+## v0.4.2 (June 28, 2019)
+
+### Notes
+
+This release is not backward compatible with the previous versions of Swarm due to changes to the wire protocol of the Retrieve Request messages. Please update your nodes.
+
+### Bug fixes and improvements
+
+* [#1503](https://github.com/ethersphere/swarm/pull/1503): network/simulation: add ExecAdapter capability to swarm simulations
+* [#1495](https://github.com/ethersphere/swarm/pull/1495): build: enable ubuntu ppa disco (19.04) builds
+* [#1395](https://github.com/ethersphere/swarm/pull/1395): swarm/storage: support for uploading 100gb files
+* [#1344](https://github.com/ethersphere/swarm/pull/1344): swarm/network, swarm/storage: simplification of fetchers
+* [#1488](https://github.com/ethersphere/swarm/pull/1488): docker: include git commit hash in swarm version
+
+## v0.4.1 (June 13, 2019)
+
+### Improvements
+
+* [#1465](https://github.com/ethersphere/swarm/pull/1465): network: bump proto versions due to change in OfferedHashesMsg
+* [#1428](https://github.com/ethersphere/swarm/pull/1428): swarm-smoke: add debug flag
+* [#1422](https://github.com/ethersphere/swarm/pull/1422): swarm/network/stream: remove dead code
+* [#1463](https://github.com/ethersphere/swarm/pull/1463): docker: create new dockerfiles that are context aware
+* [#1466](https://github.com/ethersphere/swarm/pull/1466): changelog for releases
+
+### Bug fixes
+
+* [#1460](https://github.com/ethersphere/swarm/pull/1460): storage: fix alignement panics on 32 bit arch
+* [#1422](https://github.com/ethersphere/swarm/pull/1422), [#19650](https://github.com/ethereum/go-ethereum/pull/19650): swarm/network/stream: remove dead code
+* [#1420](https://github.com/ethersphere/swarm/pull/1420): swarm, cmd: fix migration link, change loglevel severity
+* [#19594](https://github.com/ethereum/go-ethereum/pull/19594): swarm/api/http: fix bzz-hash to return ens resolved hash directly
+* [#19599](https://github.com/ethereum/go-ethereum/pull/19599): swarm/storage: fix SubscribePull to not skip chunks
+
+### Notes
+
+* Swarm has split the codebase ([go-ethereum#19661](https://github.com/ethereum/go-ethereum/pull/19661), [#1405](https://github.com/ethersphere/swarm/pull/1405)) from [ethereum/go-ethereum](https://github.com/ethereum/go-ethereum). The code is now under [ethersphere/swarm](https://github.com/ethersphere/swarm)
+* New docker images (>=0.4.0) can now be found under https://hub.docker.com/r/ethersphere/swarm
+
+## v0.4.0 (May 17, 2019)
+
+### Changes
+
+* Implemented parallel feed lookups within Swarm Feeds
+* Updated syncing protocol subscription algorithm
+* Implemented EIP-1577 - Multiaddr support for ENS
+* Improved LocalStore implementation
+* Added support for syncing tags which provide the ability to measure how long it will take for an uploaded file to sync to the network
+* Fixed data race bugs within PSS
+* Improved end-to-end integration tests
+* Various performance improvements and bug fixes
+* Improved instrumentation - metrics and OpenTracing traces
+
+### Notes
+This release is not backward compatible with the previous versions of Swarm due to the new LocalStore implementation. If you wish to keep your data, you should run a data migration prior to running this version.
+
+BZZ network ID has been updated to 4.
+
+Swarm v0.4.0 introduces major changes to the existing codebase. Among other things, the storage layer has been rewritten to be more modular and flexible in a manner that will accommodate for our future needs. Since Swarm at this point does not provide any storage guarantees, we have made the decision to not impose any migrations on the nodes that we maintain as part of the public test network, nor on our users. We have provided a [manual](https://github.com/ethersphere/swarm/blob/master/docs/Migration-v0.3-to-v0.4.md) for those of you who are running private deployments and would like to migrate your data to the new local storage schema.
--- a/21
+++ b/21
@ -1,16 +1,13 @@
-# Build Geth in a stock Go builder container
 FROM golang:1.12-alpine as builder
-
 RUN apk add --no-cache make gcc musl-dev linux-headers git
+ADD . /swarm
+WORKDIR /swarm
+RUN make swarm

-ADD . /go-ethereum
-RUN cd /go-ethereum && make geth
+FROM ethereum/client-go:v1.8.27 as geth

-# Pull Geth into a second stage deploy alpine container
-FROM alpine:latest
-
-RUN apk add --no-cache ca-certificates
-COPY --from=builder /go-ethereum/build/bin/geth /usr/local/bin/
-
-EXPOSE 8545 8546 30303 30303/udp
-ENTRYPOINT ["geth"]
+FROM alpine:3.9
+RUN apk --no-cache add ca-certificates && update-ca-certificates
+COPY --from=builder /swarm/build/bin/swarm /usr/local/bin/
+COPY --from=geth /usr/local/bin/geth /usr/local/bin/
+ENTRYPOINT ["/usr/local/bin/swarm"]
--- a/Dockerfile.alltools
+++ b/Dockerfile.alltools
@ -1,15 +1,14 @@
-# Build Geth in a stock Go builder container
 FROM golang:1.12-alpine as builder
-
 RUN apk add --no-cache make gcc musl-dev linux-headers git
+ADD . /swarm
+WORKDIR /swarm
+RUN make alltools

-ADD . /go-ethereum
-RUN cd /go-ethereum && make all
+FROM ethereum/client-go:v1.8.27 as geth

-# Pull all binaries into a second stage deploy alpine container
-FROM alpine:latest
-
-RUN apk add --no-cache ca-certificates
-COPY --from=builder /go-ethereum/build/bin/* /usr/local/bin/
-
-EXPOSE 8545 8546 30303 30303/udp
+FROM alpine:3.9
+RUN apk --no-cache add ca-certificates
+COPY --from=builder /swarm/build/bin/* /usr/local/bin/
+COPY --from=geth /usr/local/bin/geth /usr/local/bin/
+COPY docker/run-smoke.sh /run-smoke.sh
+ENTRYPOINT ["/usr/local/bin/swarm"]
--- a/142
+++ b/142
@ -2,144 +2,12 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.

-.PHONY: geth android ios geth-cross evm all test clean
-.PHONY: geth-linux geth-linux-386 geth-linux-amd64 geth-linux-mips64 geth-linux-mips64le
-.PHONY: geth-linux-arm geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64
-.PHONY: geth-darwin geth-darwin-386 geth-darwin-amd64
-.PHONY: geth-windows geth-windows-386 geth-windows-amd64
-
 GOBIN = $(shell pwd)/build/bin
-GO ?= latest

-geth:
-	build/env.sh go run build/ci.go install ./cmd/geth
+swarm:
+	build/env.sh go run build/ci.go install ./cmd/swarm
 	@echo "Done building."
-	@echo "Run \"$(GOBIN)/geth\" to launch geth."
+	@echo "Run \"$(GOBIN)/swarm\" to launch swarm."

-all:
-	build/env.sh go run build/ci.go install
-
-android:
-	build/env.sh go run build/ci.go aar --local
-	@echo "Done building."
-	@echo "Import \"$(GOBIN)/geth.aar\" to use the library."
-
-ios:
-	build/env.sh go run build/ci.go xcode --local
-	@echo "Done building."
-	@echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
-
-test: all
-	build/env.sh go run build/ci.go test
-
-lint: ## Run linters.
-	build/env.sh go run build/ci.go lint
-
-clean:
-	./build/clean_go_build_cache.sh
-	rm -fr build/_workspace/pkg/ $(GOBIN)/*
-
-# The devtools target installs tools required for 'go generate'.
-# You need to put $GOBIN (or $GOPATH/bin) in your PATH to use 'go generate'.
-
-devtools:
-	env GOBIN= go get -u golang.org/x/tools/cmd/stringer
-	env GOBIN= go get -u github.com/kevinburke/go-bindata/go-bindata
-	env GOBIN= go get -u github.com/fjl/gencodec
-	env GOBIN= go get -u github.com/golang/protobuf/protoc-gen-go
-	env GOBIN= go install ./cmd/abigen
-	@type "npm" 2> /dev/null || echo 'Please install node.js and npm'
-	@type "solc" 2> /dev/null || echo 'Please install solc'
-	@type "protoc" 2> /dev/null || echo 'Please install protoc'
-
-# Cross Compilation Targets (xgo)
-
-geth-cross: geth-linux geth-darwin geth-windows geth-android geth-ios
-	@echo "Full cross compilation done:"
-	@ls -ld $(GOBIN)/geth-*
-
-geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm geth-linux-mips64 geth-linux-mips64le
-	@echo "Linux cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-*
-
-geth-linux-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/386 -v ./cmd/geth
-	@echo "Linux 386 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep 386
-
-geth-linux-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/amd64 -v ./cmd/geth
-	@echo "Linux amd64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep amd64
-
-geth-linux-arm: geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64
-	@echo "Linux ARM cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep arm
-
-geth-linux-arm-5:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-5 -v ./cmd/geth
-	@echo "Linux ARMv5 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep arm-5
-
-geth-linux-arm-6:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-6 -v ./cmd/geth
-	@echo "Linux ARMv6 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep arm-6
-
-geth-linux-arm-7:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-7 -v ./cmd/geth
-	@echo "Linux ARMv7 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep arm-7
-
-geth-linux-arm64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm64 -v ./cmd/geth
-	@echo "Linux ARM64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep arm64
-
-geth-linux-mips:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips --ldflags '-extldflags "-static"' -v ./cmd/geth
-	@echo "Linux MIPS cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mips
-
-geth-linux-mipsle:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mipsle --ldflags '-extldflags "-static"' -v ./cmd/geth
-	@echo "Linux MIPSle cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mipsle
-
-geth-linux-mips64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips64 --ldflags '-extldflags "-static"' -v ./cmd/geth
-	@echo "Linux MIPS64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mips64
-
-geth-linux-mips64le:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips64le --ldflags '-extldflags "-static"' -v ./cmd/geth
-	@echo "Linux MIPS64le cross compilation done:"
-	@ls -ld $(GOBIN)/geth-linux-* | grep mips64le
-
-geth-darwin: geth-darwin-386 geth-darwin-amd64
-	@echo "Darwin cross compilation done:"
-	@ls -ld $(GOBIN)/geth-darwin-*
-
-geth-darwin-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=darwin/386 -v ./cmd/geth
-	@echo "Darwin 386 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-darwin-* | grep 386
-
-geth-darwin-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=darwin/amd64 -v ./cmd/geth
-	@echo "Darwin amd64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-darwin-* | grep amd64
-
-geth-windows: geth-windows-386 geth-windows-amd64
-	@echo "Windows cross compilation done:"
-	@ls -ld $(GOBIN)/geth-windows-*
-
-geth-windows-386:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=windows/386 -v ./cmd/geth
-	@echo "Windows 386 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-windows-* | grep 386
-
-geth-windows-amd64:
-	build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=windows/amd64 -v ./cmd/geth
-	@echo "Windows amd64 cross compilation done:"
-	@ls -ld $(GOBIN)/geth-windows-* | grep amd64
+alltools:
+	build/env.sh go run build/ci.go install ./cmd/...
--- a/25
+++ b/25
@ -0,0 +1,25 @@
+# Ownership by go packages
+
+swarm
+├── api ─────────────────── ethersphere
+├── bmt ─────────────────── @zelig
+├── dev ─────────────────── @lmars
+├── fuse ────────────────── @jmozah, @holisticode
+├── grafana_dashboards ──── @nonsense
+├── metrics ─────────────── @nonsense, @holisticode
+├── network ─────────────── ethersphere
+│   ├── bitvector ───────── @zelig, @janos, @gbalint
+│   ├── priorityqueue ───── @zelig, @janos, @gbalint
+│   ├── simulations ─────── @zelig
+│   └── stream ──────────── @janos, @zelig, @gbalint, @holisticode, @justelad
+│       ├── intervals ───── @janos
+│       └── testing ─────── @zelig
+├── pot ─────────────────── @zelig
+├── pss ─────────────────── @nolash, @zelig, @nonsense
+├── services ────────────── @zelig
+├── state ───────────────── @justelad
+├── storage ─────────────── ethersphere
+│   ├── encryption ──────── @gbalint, @zelig, @nagydani
+│   ├── mock ────────────── @janos
+│   └── feed ────────────── @nolash, @jpeletier
+└── testutil ────────────── @lmars
--- a/README.md
+++ b/README.md
@ -1,344 +1,334 @@
-## Go Ethereum
+## Swarm  <!-- omit in toc -->

-Official Golang implementation of the Ethereum protocol.
+[https://swarm.ethereum.org](https://swarm.ethereum.org)

-[![API Reference](
-https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667
-)](https://godoc.org/github.com/ethereum/go-ethereum)
-[![Go Report Card](https://goreportcard.com/badge/github.com/ethereum/go-ethereum)](https://goreportcard.com/report/github.com/ethereum/go-ethereum)
-[![Travis](https://travis-ci.org/ethereum/go-ethereum.svg?branch=master)](https://travis-ci.org/ethereum/go-ethereum)
-[![Discord](https://img.shields.io/badge/discord-join%20chat-blue.svg)](https://discord.gg/nthXNEv)
+Swarm is a distributed storage platform and content distribution service, a native base layer service of the ethereum web3 stack. The primary objective of Swarm is to provide a decentralized and redundant store for dapp code and data as well as block chain and state data. Swarm is also set out to provide various base layer services for web3, including node-to-node messaging, media streaming, decentralised database services and scalable state-channel infrastructure for decentralised service economies.

-Automated builds are available for stable releases and the unstable master branch. Binary
-archives are published at https://geth.ethereum.org/downloads/.
+[![Travis](https://travis-ci.org/ethersphere/swarm.svg?branch=master)](https://travis-ci.org/ethersphere/swarm)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ethersphere/orange-lounge?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+## Table of Contents  <!-- omit in toc -->
+
+- [Building the source](#Building-the-source)
+- [Running Swarm](#Running-Swarm)
+  - [Verifying that your local Swarm node is running](#Verifying-that-your-local-Swarm-node-is-running)
+  - [Ethereum Name Service resolution](#Ethereum-Name-Service-resolution)
+- [Documentation](#Documentation)
+- [Docker](#Docker)
+  - [Docker tags](#Docker-tags)
+  - [Swarm command line arguments](#Swarm-command-line-arguments)
+- [Developers Guide](#Developers-Guide)
+  - [Go Environment](#Go-Environment)
+  - [Vendored Dependencies](#Vendored-Dependencies)
+  - [Testing](#Testing)
+  - [Profiling Swarm](#Profiling-Swarm)
+  - [Metrics and Instrumentation in Swarm](#Metrics-and-Instrumentation-in-Swarm)
+    - [Visualizing metrics](#Visualizing-metrics)
+- [Public Gateways](#Public-Gateways)
+- [Swarm Dapps](#Swarm-Dapps)
+- [Contributing](#Contributing)
+- [License](#License)

 ## Building the source

-For prerequisites and detailed build instructions please read the [Installation Instructions](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum) on the wiki.
+Building Swarm requires Go (version 1.11 or later).

-Building `geth` requires both a Go (version 1.10 or later) and a C compiler. You can install
-them using your favourite package manager. Once the dependencies are installed, run
+To simply compile the `swarm` binary without a `GOPATH`:

-```shell
-make geth
+```bash
+$ git clone https://github.com/ethersphere/swarm
+$ cd swarm
+$ make swarm
 ```

-or, to build the full suite of utilities:
+You will find the binary under `./build/bin/swarm`.

-```shell
-make all
+To build a vendored `swarm` using `go get` you must have `GOPATH` set. Then run:
+
+```bash
+$ go get -d github.com/ethersphere/swarm
+$ go install github.com/ethersphere/swarm/cmd/swarm
 ```

-## Executables
+## Running Swarm

-The go-ethereum project comes with several wrappers/executables found in the `cmd`
-directory.
-
-|    Command    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| :-----------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-|  **`geth`**   | Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default), archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as a gateway into the Ethereum network via JSON RPC endpoints exposed on top of HTTP, WebSocket and/or IPC transports. `geth --help` and the [CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options) for command line options.          |
-|   `abigen`    | Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages. It operates on plain [Ethereum contract ABIs](https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI) with expanded functionality if the contract bytecode is also available. However, it also accepts Solidity source files, making development much more streamlined. Please see our [Native DApps](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts) wiki page for details. |
-|  `bootnode`   | Stripped down version of our Ethereum client implementation that only takes part in the network node discovery protocol, but does not run any of the higher level application protocols. It can be used as a lightweight bootstrap node to aid in finding peers in private networks.                                                                                                                                                                                                                                                                 |
-|     `evm`     | Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow isolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug`).                                                                                                                                                                                                                                                                     |
-| `gethrpctest` | Developer utility tool to support our [ethereum/rpc-test](https://github.com/ethereum/rpc-tests) test suite which validates baseline conformity to the [Ethereum JSON RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC) specs. Please see the [test suite's readme](https://github.com/ethereum/rpc-tests/blob/master/README.md) for details.                                                                                                                                                                                                     |
-|   `rlpdump`   | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://github.com/ethereum/wiki/wiki/RLP)) dumps (data encoding used by the Ethereum protocol both network as well as consensus wise) to user-friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`).                                                                                                                                                                                                                                 |
-|   `puppeth`   | a CLI wizard that aids in creating a new Ethereum network.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-
-## Running `geth`
-
-Going through all the possible command line flags is out of scope here (please consult our
-[CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options)),
-but we've enumerated a few common parameter combos to get you up to speed quickly
-on how you can run your own `geth` instance.
-
-### Full node on the main Ethereum network
-
-By far the most common scenario is people wanting to simply interact with the Ethereum
-network: create accounts; transfer funds; deploy and interact with contracts. For this
-particular use-case the user doesn't care about years-old historical data, so we can
-fast-sync quickly to the current state of the network. To do so:
-
-```shell
-$ geth console
+```bash
+$ swarm
 ```

-This command will:
- * Start `geth` in fast sync mode (default, can be changed with the `--syncmode` flag),
-   causing it to download more data in exchange for avoiding processing the entire history
-   of the Ethereum network, which is very CPU intensive.
- * Start up `geth`'s built-in interactive [JavaScript console](https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console),
-   (via the trailing `console` subcommand) through which you can invoke all official [`web3` methods](https://github.com/ethereum/wiki/wiki/JavaScript-API)
-   as well as `geth`'s own [management APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs).
-   This tool is optional and if you leave it out you can always attach to an already running
-   `geth` instance with `geth attach`.
+If you don't have an account yet, then you will be prompted to create one and secure it with a password:

-### A Full node on the Ethereum test network
-
-Transitioning towards developers, if you'd like to play around with creating Ethereum
-contracts, you almost certainly would like to do that without any real money involved until
-you get the hang of the entire system. In other words, instead of attaching to the main
-network, you want to join the **test** network with your node, which is fully equivalent to
-the main network, but with play-Ether only.
-
-```shell
-$ geth --testnet console
+```
+Your new account is locked with a password. Please give a password. Do not forget this password.
+Passphrase:
+Repeat passphrase:
 ```

-The `console` subcommand has the exact same meaning as above and they are equally
-useful on the testnet too. Please see above for their explanations if you've skipped here.
+If you have multiple accounts created, then you'll have to choose one of the accounts by using the `--bzzaccount` flag.

-Specifying the `--testnet` flag, however, will reconfigure your `geth` instance a bit:
+```bash
+$ swarm --bzzaccount <your-account-here>

- * Instead of using the default data directory (`~/.ethereum` on Linux for example), `geth`
-   will nest itself one level deeper into a `testnet` subfolder (`~/.ethereum/testnet` on
-   Linux). Note, on OSX and Linux this also means that attaching to a running testnet node
-   requires the use of a custom endpoint since `geth attach` will try to attach to a
-   production node endpoint by default. E.g.
-   `geth attach <datadir>/testnet/geth.ipc`. Windows users are not affected by
-   this.
- * Instead of connecting the main Ethereum network, the client will connect to the test
-   network, which uses different P2P bootnodes, different network IDs and genesis states.
-   
-*Note: Although there are some internal protective measures to prevent transactions from
-crossing over between the main network and test network, you should make sure to always
-use separate accounts for play-money and real-money. Unless you manually move
-accounts, `geth` will by default correctly separate the two networks and will not make any
-accounts available between them.*
-
-### Full node on the Rinkeby test network
-
-The above test network is a cross-client one based on the ethash proof-of-work consensus
-algorithm. As such, it has certain extra overhead and is more susceptible to reorganization
-attacks due to the network's low difficulty/security. Go Ethereum also supports connecting
-to a proof-of-authority based test network called [*Rinkeby*](https://www.rinkeby.io)
-(operated by members of the community). This network is lighter, more secure, but is only
-supported by go-ethereum.
-
-```shell
-$ geth --rinkeby console
+# example
+$ swarm --bzzaccount 2f1cd699b0bf461dcfbf0098ad8f5587b038f0f1
 ```

-### Configuration
+### Verifying that your local Swarm node is running

-As an alternative to passing the numerous flags to the `geth` binary, you can also pass a
-configuration file via:
+When running, Swarm is accessible through an HTTP API on port 8500.

-```shell
-$ geth --config /path/to/your_config.toml
+Confirm that it is up and running by pointing your browser to http://localhost:8500
+
+### Ethereum Name Service resolution
+
+The Ethereum Name Service is the Ethereum equivalent of DNS in the classic web. In order to use ENS to resolve names to Swarm content hashes (e.g. `bzz://theswarm.eth`), `swarm` has to connect to a `geth` instance, which is synced with the Ethereum mainnet. This is done using the `--ens-api` flag.
+
+```bash
+$ swarm --bzzaccount <your-account-here> \
+        --ens-api '$HOME/.ethereum/geth.ipc'
+
+# in our example
+$ swarm --bzzaccount 2f1cd699b0bf461dcfbf0098ad8f5587b038f0f1 \
+        --ens-api '$HOME/.ethereum/geth.ipc'
 ```

-To get an idea how the file should look like you can use the `dumpconfig` subcommand to
-export your existing configuration:
+For more information on usage, features or command line flags, please consult the Documentation.

-```shell
-$ geth --your-favourite-flags dumpconfig
+## Documentation
+
+Swarm documentation can be found at [https://swarm-guide.readthedocs.io](https://swarm-guide.readthedocs.io).
+
+## Docker
+
+Swarm container images are available at Docker Hub: [ethersphere/swarm](https://hub.docker.com/r/ethersphere/swarm)
+
+### Docker tags
+
+* `latest` - latest stable release
+* `edge` - latest build from `master`
+* `v0.x.y` - specific stable release
+
+### Swarm command line arguments
+
+All Swarm command line arguments are supported and can be sent as part of the CMD field to the Docker container.
+
+**Examples:**
+
+Running a Swarm container from the command line
+
+```bash
+$ docker run -it ethersphere/swarm \
+                            --debug \
+                            --verbosity 4
 ```

-*Note: This works only with `geth` v1.6.0 and above.*

-#### Docker quick start
+Running a Swarm container with custom ENS endpoint

-One of the quickest ways to get Ethereum up and running on your machine is by using
-Docker:
-
-```shell
-docker run -d --name ethereum-node -v /Users/alice/ethereum:/root \
-           -p 8545:8545 -p 30303:30303 \
-           ethereum/client-go
+```bash
+$ docker run -it ethersphere/swarm \
+                            --ens-api http://1.2.3.4:8545 \
+                            --debug \
+                            --verbosity 4
 ```

-This will start `geth` in fast-sync mode with a DB memory allowance of 1GB just as the
-above command does.  It will also create a persistent volume in your home directory for
-saving your blockchain as well as map the default ports. There is also an `alpine` tag
-available for a slim version of the image.
+Running a Swarm container with metrics enabled

-Do not forget `--rpcaddr 0.0.0.0`, if you want to access RPC from other containers
-and/or hosts. By default, `geth` binds to the local interface and RPC endpoints is not
-accessible from the outside.
-
-### Programmatically interfacing `geth` nodes
-
-As a developer, sooner rather than later you'll want to start interacting with `geth` and the
-Ethereum network via your own programs and not manually through the console. To aid
-this, `geth` has built-in support for a JSON-RPC based APIs ([standard APIs](https://github.com/ethereum/wiki/wiki/JSON-RPC)
-and [`geth` specific APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs)).
-These can be exposed via HTTP, WebSockets and IPC (UNIX sockets on UNIX based
-platforms, and named pipes on Windows).
-
-The IPC interface is enabled by default and exposes all the APIs supported by `geth`,
-whereas the HTTP and WS interfaces need to manually be enabled and only expose a
-subset of APIs due to security reasons. These can be turned on/off and configured as
-you'd expect.
-
-HTTP based JSON-RPC API options:
-
-  * `--rpc` Enable the HTTP-RPC server
-  * `--rpcaddr` HTTP-RPC server listening interface (default: `localhost`)
-  * `--rpcport` HTTP-RPC server listening port (default: `8545`)
-  * `--rpcapi` API's offered over the HTTP-RPC interface (default: `eth,net,web3`)
-  * `--rpccorsdomain` Comma separated list of domains from which to accept cross origin requests (browser enforced)
-  * `--ws` Enable the WS-RPC server
-  * `--wsaddr` WS-RPC server listening interface (default: `localhost`)
-  * `--wsport` WS-RPC server listening port (default: `8546`)
-  * `--wsapi` API's offered over the WS-RPC interface (default: `eth,net,web3`)
-  * `--wsorigins` Origins from which to accept websockets requests
-  * `--ipcdisable` Disable the IPC-RPC server
-  * `--ipcapi` API's offered over the IPC-RPC interface (default: `admin,debug,eth,miner,net,personal,shh,txpool,web3`)
-  * `--ipcpath` Filename for IPC socket/pipe within the datadir (explicit paths escape it)
-
-You'll need to use your own programming environments' capabilities (libraries, tools, etc) to
-connect via HTTP, WS or IPC to a `geth` node configured with the above flags and you'll
-need to speak [JSON-RPC](https://www.jsonrpc.org/specification) on all transports. You
-can reuse the same connection for multiple requests!
-
-**Note: Please understand the security implications of opening up an HTTP/WS based
-transport before doing so! Hackers on the internet are actively trying to subvert
-Ethereum nodes with exposed APIs! Further, all browser tabs can access locally
-running web servers, so malicious web pages could try to subvert locally available
-APIs!**
-
-### Operating a private network
-
-Maintaining your own private network is more involved as a lot of configurations taken for
-granted in the official networks need to be manually set up.
-
-#### Defining the private genesis state
-
-First, you'll need to create the genesis state of your networks, which all nodes need to be
-aware of and agree upon. This consists of a small JSON file (e.g. call it `genesis.json`):
-
-```json
-{
-  "config": {
-    "chainId": 0,
-    "homesteadBlock": 0,
-    "eip155Block": 0,
-    "eip158Block": 0
-  },
-  "alloc": {},
-  "coinbase": "0x0000000000000000000000000000000000000000",
-  "difficulty": "0x20000",
-  "extraData": "",
-  "gasLimit": "0x2fefd8",
-  "nonce": "0x0000000000000042",
-  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "timestamp": "0x00"
-}
+```bash
+$ docker run -it ethersphere/swarm \
+                            --debug \
+                            --metrics \
+                            --metrics.influxdb.export \
+                            --metrics.influxdb.endpoint "http://localhost:8086" \
+                            --metrics.influxdb.username "user" \
+                            --metrics.influxdb.password "pass" \
+                            --metrics.influxdb.database "metrics" \
+                            --metrics.influxdb.host.tag "localhost" \
+                            --verbosity 4
 ```

-The above fields should be fine for most purposes, although we'd recommend changing
-the `nonce` to some random value so you prevent unknown remote nodes from being able
-to connect to you. If you'd like to pre-fund some accounts for easier testing, you can
-populate the `alloc` field with account configs:
+Running a Swarm container with tracing and pprof server enabled

-```json
-"alloc": {
-  "0x0000000000000000000000000000000000000001": {
-    "balance": "111111111"
-  },
-  "0x0000000000000000000000000000000000000002": {
-    "balance": "222222222"
-  }
-}
+```bash
+$ docker run -it ethersphere/swarm \
+                            --debug \
+                            --tracing \
+                            --tracing.endpoint 127.0.0.1:6831 \
+                            --tracing.svc myswarm \
+                            --pprof \
+                            --pprofaddr 0.0.0.0 \
+                            --pprofport 6060
 ```

-With the genesis state defined in the above JSON file, you'll need to initialize **every**
-`geth` node with it prior to starting it up to ensure all blockchain parameters are correctly
-set:
+Running a Swarm container with a custom data directory mounted from a volume and a password file to unlock the swarm account

-```shell
-$ geth init path/to/genesis.json
+```bash
+$ docker run -it -v $PWD/hostdata:/data \
+                 -v $PWD/password:/password \
+                 ethersphere/swarm \
+                            --datadir /data \
+                            --password /password \
+                            --debug \
+                            --verbosity 4
 ```

-#### Creating the rendezvous point
+## Developers Guide

-With all nodes that you want to run initialized to the desired genesis state, you'll need to
-start a bootstrap node that others can use to find each other in your network and/or over
-the internet. The clean way is to configure and run a dedicated bootnode:
+### Go Environment

-```shell
-$ bootnode --genkey=boot.key
-$ bootnode --nodekey=boot.key
+We assume that you have Go v1.11 installed, and `GOPATH` is set.
+
+You must have your working copy under `$GOPATH/src/github.com/ethersphere/swarm`.
+
+Most likely you will be working from your fork of `swarm`, let's say from `github.com/nirname/swarm`. Clone or move your fork into the right place:
+
+```bash
+$ git clone git@github.com:nirname/swarm.git $GOPATH/src/github.com/ethersphere/swarm
 ```

-With the bootnode online, it will display an [`enode` URL](https://github.com/ethereum/wiki/wiki/enode-url-format)
-that other nodes can use to connect to it and exchange peer information. Make sure to
-replace the displayed IP address information (most probably `[::]`) with your externally
-accessible IP to get the actual `enode` URL.

-*Note: You could also use a full-fledged `geth` node as a bootnode, but it's the less
-recommended way.*
+### Vendored Dependencies

-#### Starting up your member nodes
+All dependencies are tracked in the `vendor` directory. We use `govendor` to manage them.

-With the bootnode operational and externally reachable (you can try
-`telnet <ip> <port>` to ensure it's indeed reachable), start every subsequent `geth`
-node pointed to the bootnode for peer discovery via the `--bootnodes` flag. It will
-probably also be desirable to keep the data directory of your private network separated, so
-do also specify a custom `--datadir` flag.
+If you want to add a new dependency, run `govendor fetch <import-path>`, then commit the result.

-```shell
-$ geth --datadir=path/to/custom/data/folder --bootnodes=<bootnode-enode-url-from-above>
+If you want to update all dependencies to their latest upstream version, run `govendor fetch +v`.
+
+
+### Testing
+
+This section explains how to run unit, integration, and end-to-end tests in your development sandbox.
+
+Testing one library:
+
+```bash
+$ go test -v -cpu 4 ./api
 ```

-*Note: Since your network will be completely cut off from the main and test networks, you'll
-also need to configure a miner to process transactions and create new blocks for you.*
+Note: Using options -cpu (number of cores allowed) and -v (logging even if no error) is recommended.

-#### Running a private miner
+Testing only some methods:

-Mining on the public Ethereum network is a complex task as it's only feasible using GPUs,
-requiring an OpenCL or CUDA enabled `ethminer` instance. For information on such a
-setup, please consult the [EtherMining subreddit](https://www.reddit.com/r/EtherMining/)
-and the [Genoil miner](https://github.com/Genoil/cpp-ethereum) repository.
-
-In a private network setting, however a single CPU miner instance is more than enough for
-practical purposes as it can produce a stable stream of blocks at the correct intervals
-without needing heavy resources (consider running on a single thread, no need for multiple
-ones either). To start a `geth` instance for mining, run it with all your usual flags, extended
-by:
-
-```shell
-$ geth <usual-flags> --mine --minerthreads=1 --etherbase=0x0000000000000000000000000000000000000000
+```bash
+$ go test -v -cpu 4 ./api -run TestMethod
 ```

-Which will start mining blocks and transactions on a single CPU thread, crediting all
-proceedings to the account specified by `--etherbase`. You can further tune the mining
-by changing the default gas limit blocks converge to (`--targetgaslimit`) and the price
-transactions are accepted at (`--gasprice`).
+Note: here all tests with prefix TestMethod will be run, so if you got TestMethod, TestMethod1, then both!

-## Contribution
+Running benchmarks:

-Thank you for considering to help out with the source code! We welcome contributions
-from anyone on the internet, and are grateful for even the smallest of fixes!
+```bash
+$ go test -v -cpu 4 -bench . -run BenchmarkJoin
+```

-If you'd like to contribute to go-ethereum, please fork, fix, commit and send a pull request
-for the maintainers to review and merge into the main code base. If you wish to submit
-more complex changes though, please check up with the core devs first on [our gitter channel](https://gitter.im/ethereum/go-ethereum)
-to ensure those changes are in line with the general philosophy of the project and/or get
-some early feedback which can make both your efforts much lighter as well as our review
-and merge procedures quick and simple.
+
+### Profiling Swarm
+
+This section explains how to add Go `pprof` profiler to Swarm
+
+If `swarm` is started with the `--pprof` option, a debugging HTTP server is made available on port 6060.
+
+You can bring up http://localhost:6060/debug/pprof to see the heap, running routines etc.
+
+By clicking full goroutine stack dump (clicking http://localhost:6060/debug/pprof/goroutine?debug=2) you can generate trace that is useful for debugging.
+
+
+### Metrics and Instrumentation in Swarm
+
+This section explains how to visualize and use existing Swarm metrics and how to instrument Swarm with a new metric.
+
+Swarm metrics system is based on the `go-metrics` library.
+
+The most common types of measurements we use in Swarm are `counters` and `resetting timers`. Consult the `go-metrics` documentation for full reference of available types.
+
+```go
+// incrementing a counter
+metrics.GetOrRegisterCounter("network.stream.received_chunks", nil).Inc(1)
+
+// measuring latency with a resetting timer
+start := time.Now()
+t := metrics.GetOrRegisterResettingTimer("http.request.GET.time"), nil)
+...
+t := UpdateSince(start)
+```
+
+#### Visualizing metrics
+
+Swarm supports an InfluxDB exporter. Consult the help section to learn about the command line arguments used to configure it:
+
+```bash
+$ swarm --help | grep metrics
+```
+
+We use Grafana and InfluxDB to visualise metrics reported by Swarm. We keep our Grafana dashboards under version control at https://github.com/ethersphere/grafana-dashboards. You could use them or design your own.
+
+We have built a tool to help with automatic start of Grafana and InfluxDB and provisioning of dashboards at https://github.com/nonsense/stateth, which requires that you have Docker installed.
+
+Once you have `stateth` installed, and you have Docker running locally, you have to:
+
+1. Run `stateth` and keep it running in the background
+
+```bash
+$ stateth --rm --grafana-dashboards-folder $GOPATH/src/github.com/ethersphere/grafana-dashboards --influxdb-database metrics
+```
+
+2. Run `swarm` with at least the following params:
+
+```bash
+--metrics \
+--metrics.influxdb.export \
+--metrics.influxdb.endpoint "http://localhost:8086" \
+--metrics.influxdb.username "admin" \
+--metrics.influxdb.password "admin" \
+--metrics.influxdb.database "metrics"
+```
+
+3. Open Grafana at http://localhost:3000 and view the dashboards to gain insight into Swarm.
+
+
+## Public Gateways
+
+Swarm offers a local HTTP proxy API that Dapps can use to interact with Swarm. The Ethereum Foundation is hosting a public gateway, which allows free access so that people can try Swarm without running their own node.
+
+The Swarm public gateways are temporary and users should not rely on their existence for production services.
+
+The Swarm public gateway can be found at https://swarm-gateways.net and is always running the latest `stable` Swarm release.
+
+## Swarm Dapps
+
+You can find a few reference Swarm decentralised applications at: https://swarm-gateways.net/bzz:/swarmapps.eth
+
+Their source code can be found at: https://github.com/ethersphere/swarm-dapps
+
+## Contributing
+
+Thank you for considering to help out with the source code! We welcome contributions from
+anyone on the internet, and are grateful for even the smallest of fixes!
+
+If you'd like to contribute to Swarm, please fork, fix, commit and send a pull request
+for the maintainers to review and merge into the main code base. If you wish to submit more
+complex changes though, please check up with the core devs first on [our Swarm gitter channel](https://gitter.im/ethersphere/orange-lounge)
+to ensure those changes are in line with the general philosophy of the project and/or get some
+early feedback which can make both your efforts much lighter as well as our review and merge
+procedures quick and simple.

 Please make sure your contributions adhere to our coding guidelines:

- * Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting)
-   guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)).
- * Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary)
-   guidelines.
+ * Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting) guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)).
+ * Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines.
 * Pull requests need to be based on and opened against the `master` branch.
+ * [Code review guidelines](https://github.com/ethersphere/swarm/blob/master/docs/Code-Review-Guidelines.md).
 * Commit messages should be prefixed with the package(s) they modify.
-   * E.g. "eth, rpc: make trace configs optional"
+   * E.g. "fuse: ignore default manifest entry"

-Please see the [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
-for more details on configuring your environment, managing project dependencies, and
-testing procedures.

 ## License

-The go-ethereum library (i.e. all code outside of the `cmd` directory) is licensed under the
-[GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html),
-also included in our repository in the `COPYING.LESSER` file.
+The swarm library (i.e. all code outside of the `cmd` directory) is licensed under the
+[GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html), also
+included in our repository in the `COPYING.LESSER` file.

-The go-ethereum binaries (i.e. all code inside of the `cmd` directory) is licensed under the
-[GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html), also
-included in our repository in the `COPYING` file.
+The swarm binaries (i.e. all code inside of the `cmd` directory) is licensed under the
+[GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html), also included
+in our repository in the `COPYING` file.
--- a/SECURITY.md
+++ b/SECURITY.md
@ -1,120 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Please see Releases. We recommend to use the most recent released version.  
-
-## Audit reports
-
-Audit reports are published in the `docs` folder: https://github.com/ethereum/go-ethereum/tree/master/docs/audits 
-
-
-| Scope | Date | Report Link |
-| ------- | ------- | ----------- |
-| `geth` | 20170425 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2017-04-25_Geth-audit_Truesec.pdf) |
-| `clef` | 20180914 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2018-09-14_Clef-audit_NCC.pdf) |
-
-
-
-## Reporting a Vulnerability
-
-**Please do not file a public ticket** mentioning the vulnerability.
-
-To find out how to disclose a vulnerability in Ethereum visit [https://bounty.ethereum.org](https://bounty.ethereum.org) or email bounty@ethereum.org.
-
-The following key may be used to communicate sensitive information to developers.
-
-Fingerprint: `AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A`
-
-
-```
-----BEGIN PGP PUBLIC KEY BLOCK-----
-Version: GnuPG v1
-
-mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaY
-neAk3Bp182GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9
-L8c8yiqry1ZTCmYMqCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUi
-m+y7buJDtoNf7YILlhDQXN8qlHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0b
-fUo9pexOn7LS4SojoJmsm/5dp6AoKlac48cZU5zwR9AYcq/nvkrfmf2WkObg/xRd
-EvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/yPFE335k+ujjZCPOu7OwjzDk7
-M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXChoyI8vbfp4dGvCvYqv
-QAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+FnQOUgg2H
-h8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
-2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZ
-EZCjMXxB8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQAB
-tDlFdGhlcmV1bSBGb3VuZGF0aW9uIFNlY3VyaXR5IFRlYW0gPHNlY3VyaXR5QGV0
-aGVyZXVtLm9yZz6JAj4EEwECACgCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheA
-BQJaCWH6BQkFo2BYAAoJEOiNMzT6X2oK+DEP/3H6dxkm0hvHZKoHLVuuxcu3EHYo
-k5sd3MMWPrZSN8qzZnY7ayEDMxnarWOizc+2jfOxfJlzX/g8lR1/fsHdWPFPhPoV
-Qk8ygrHn1H8U8+rpw/U03BqmqHpYCDzJ+CIis9UWROniqXw1nuqu/FtWOsdWxNKh
-jUo6k/0EsaXsxRPzgJv7fEUcVcQ7as/C3x9sy3muc2gvgA4/BKoGPb1/U0GuA8lV
-fDIDshAggmnSUAg+TuYSAAdoFQ1sKwFMPigcLJF2eyKuK3iUyixJrec/c4LSf3wA
-cGghbeuqI8INP0Y2zvXDQN2cByxsFAuoZG+m0cyKGaDH2MVUvOKKYqn/03qvrf15
-AWAsW0l0yQwOTCo3FbsNzemClm5Bj/xH0E4XuwXwChcMCMOWJrFoxyvCEI+keoQc
-c08/a8/MtS7vBAABXwOziSmm6CNqmzpWrh/fDrjlJlba9U3MxzvqU3IFlTdMratv
-6V+SgX+L25lCzW4NxxUavoB8fAlvo8lxpHKo24FP+RcLQ8XqkU3RiUsgRjQRFOqQ
-TaJcsp8mimmiYyf24mNu6b48pi+a5c/eQR9w59emeEUZqsJU+nqv8BWIIp7o4Agh
-NYnKjkhPlY5e1fLVfAHIADZFynWwRPkPMJSrBiP5EtcOFxQGHGjRxU/KjXkvE0hV
-xYb1PB8pWMTu/beeiQI+BBMBAgAoBQJYJd7YAhsDBQkB4TOABgsJCAcDAgYVCAIJ
-CgsEFgIDAQIeAQIXgAAKCRDojTM0+l9qCplDD/9IZ2i+m1cnqQKtiyHbyFGx32oL
-fzqPylX2bOG5DPsSTorSUdJMGVfT04oVxXc4S/2DVnNvi7RAbSiLapCWSplgtBOj
-j1xlblOoXxT3m7s1XHGCX5tENxI9fVSSPVKJn+fQaWpPB2MhBA+1lUI6GJ+11T7K
-J8LrP/fiw1/nOb7rW61HW44Gtyox23sA/d1+DsFVaF8hxJlNj5coPKr8xWzQ8pQl
-juzdjHDukjevuw4rRmRq9vozvj9keEU9XJ5dldyEVXFmdDk7KT0p0Rla9nxYhzf/
-r/Bv8Bzy0HCWRb2D31BjXXGG05oVnYmNGxGFxYja4MwgrMmne3ilEVjfUJsapsqi
-w41BAyQgIdfREulYN7ahsF5PrjVAqBd9IGtE8ULelF2SQxEBQBngEkP0ahP6tRAL
-i7/CBjPKOyKijtqVny7qrGOnU2ygcA88/WDibexDhrjz0Gx8WmErU7rIWZiZ5u4Y
-vJYVRo0+6rBCXRPeSJfiP5h1p17Anr2l42boAYslfcrzquB8MHtrNcyn650OLtHG
-nbxgIdniKrpuzGN6Opw+O2id2JhD1/1p4SOemwAmthplr1MIyOHNP3q93rEj2J7h
-5zPS/AJuKkMDFUpslPNLQjCOwPXtdzL7/kUZGBSyez1T3TaW1uY6l9XaJJRaSn+v
-1zPgfp4GJ3lPs4AlAbQ0RXRoZXJldW0gRm91bmRhdGlvbiBCdWcgQm91bnR5IDxi
-b3VudHlAZXRoZXJldW0ub3JnPokCPgQTAQIAKAIbAwYLCQgHAwIGFQgCCQoLBBYC
-AwECHgECF4AFAloJYfoFCQWjYFgACgkQ6I0zNPpfagoENg/+LnSaVeMxiGVtcjWl
-b7Xd73yrEy4uxiESS1AalW9mMf7oZzfI05f7QIQlaLAkNac74vZDJbPKjtb7tpMO
-RFhRZMCveq6CPKU6pd1SI8IUVUKwpEe6AJP3lHdVP57dquieFE2HlYKm6uHbCGWU
-0cjyTA+uu2KbgCHGmofsPY/xOcZLGEHTHqa5w60JJAQm+BSDKnw8wTyrxGvA3EK/
-ePSvOZMYa+iw6vYuZeBIMbdiXR/A2keBi3GuvqB8tDMj7P22TrH5mVDm3zNqGYD6
-amDPeiWp4cztY3aZyLcgYotqXPpDceZzDn+HopBPzAb/llCdE7bVswKRhphVMw4b
-bhL0R/TQY7Sf6TK2LKSBrjv0DWOSijikE71SJcBnJvHU7EpKrQQ0lMGclm3ynyji
-Nf0YTPXQt4I+fwTmOew2GFeK3UytNWbWI7oXX7Nm4bj9bhf3IJ0kmZb/Gs73+xII
-e7Rz52Mby436tWyQIQiF9ITYNGvNf53TwBBZMn0pKPiTyr3Ur7FHEotkEOFNh1//
-4zQY10XxuBdLrYGyZ4V8xHJM+oKre8Eg2R9qHXVbjvErHE+7CvgnV7YUip0criPr
-BlKRvuoJaSliH2JFhSjWVrkPmFGrWN0BAx10yIqMnEplfKeHf4P9Elek3oInS8WP
-G1zJG6s/t5+hQK0X37+TB+6rd3GJAj4EEwECACgFAlgl4TsCGwMFCQHhM4AGCwkI
-BwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEOiNMzT6X2oKzf8P/iIKd77WHTbp4pMN
-8h52HyZJtDJmjA1DPZrbGl1TesW/Z9uTd12txlgqZnbG2GfN9+LSP6EOPzR6v2xC
-OVhR+RdWhZDJJuQCVS7lJIqQrZgmeTZG0TyQPZdLjVFBOrrhVwYX+HXbu429IzHr
-URf5InyR1QgqOXyElDYS6e28HFqvaoA0DWTWDDqOLPVl+U5fuceIE2XXdv3AGLeP
-Yf8J5MPobjPiZtBqI6S6iENY2Yn35qLX+axeC/iYSCHVtFuCCIdb/QYR1ZZV8Ps/
-aI9DwC7LU+YfPw7iqCIoqxSeA3o1PORkdSigEg3jtfRv5UqVo9a0oBb9jdoADsat
-F/gW0E7mto3XGOiaR0eB9SSdsM3x7Bz4A0HIGNaxpZo1RWqlO91leP4c13Px7ISv
-5OGXfLg+M8qb+qxbGd1HpitGi9s1y1aVfEj1kOtZ0tN8eu+Upg5WKwPNBDX3ar7J
-9NCULgVSL+E79FG+zXw62gxiQrLfKzm4wU/9L5wVkwQnm29hLJ0tokrSBZFnc/1l
-7OC+GM63tYicKkY4rqmoWUeYx7IwFH9mtDtvR1RxO85RbQhZizwpZpdpRkH0DqZu
-ZJRmRa5r7rPqmfa7d+VIFhz2Xs8pJMLVqxTsLKcLglmjw7aOrYG0SWeH7YraXWGD
-N3SlvSBiVwcK7QUKzLLvpadLwxfsuQINBFgl3tgBEACbgq6HTN5gEBi0lkD/MafI
-nmNi+59U5gRGYqk46WlfRjhHudXjDpgD0lolGb4hYontkMaKRlCg2Rvgjvk3Zve0
-PKWjKw7gr8YBa9fMFY8BhAXI32OdyI9rFhxEZFfWAfwKVmT19BdeAQRFvcfd+8w8
-f1XVc+zddULMJFBTr+xKDlIRWwTkdLPQeWbjo0eHl/g4tuLiLrTxVbnj26bf+2+1
-DbM/w5VavzPrkviHqvKe/QP/gay4QDViWvFgLb90idfAHIdsPgflp0VDS5rVHFL6
-D73rSRdIRo3I8c8mYoNjSR4XDuvgOkAKW9LR3pvouFHHjp6Fr0GesRbrbb2EG66i
-PsR99MQ7FqIL9VMHPm2mtR+XvbnKkH2rYyEqaMbSdk29jGapkAWle4sIhSKk749A
-4tGkHl08KZ2N9o6GrfUehP/V2eJLaph2DioFL1HxRryrKy80QQKLMJRekxigq8gr
-eW8xB4zuf9Mkuou+RHNmo8PebHjFstLigiD6/zP2e+4tUmrT0/JTGOShoGMl8Rt0
-VRxdPImKun+4LOXbfOxArOSkY6i35+gsgkkSy1gTJE0BY3S9auT6+YrglY/TWPQ9
-IJxWVOKlT+3WIp5wJu2bBKQ420VLqDYzkoWytel/bM1ACUtipMiIVeUs2uFiRjpz
-A1Wy0QHKPTdSuGlJPRrfcQARAQABiQIlBBgBAgAPAhsMBQJaCWIIBQkFo2BYAAoJ
-EOiNMzT6X2oKgSwQAKKs7BGF8TyZeIEO2EUK7R2bdQDCdSGZY06tqLFg3IHMGxDM
-b/7FVoa2AEsFgv6xpoebxBB5zkhUk7lslgxvKiSLYjxfNjTBltfiFJ+eQnf+OTs8
-KeR51lLa66rvIH2qUzkNDCCTF45H4wIDpV05AXhBjKYkrDCrtey1rQyFp5fxI+0I
-Q1UKKXvzZK4GdxhxDbOUSd38MYy93nqcmclGSGK/gF8XiyuVjeifDCM6+T1NQTX0
-K9lneidcqtBDvlggJTLJtQPO33o5EHzXSiud+dKth1uUhZOFEaYRZoye1YE3yB0T
-NOOE8fXlvu8iuIAMBSDL9ep6sEIaXYwoD60I2gHdWD0lkP0DOjGQpi4ouXM3Edsd
-5MTi0MDRNTij431kn8T/D0LCgmoUmYYMBgbwFhXr67axPZlKjrqR0z3F/Elv0ZPP
-cVg1tNznsALYQ9Ovl6b5M3cJ5GapbbvNWC7yEE1qScl9HiMxjt/H6aPastH63/7w
-cN0TslW+zRBy05VNJvpWGStQXcngsSUeJtI1Gd992YNjUJq4/Lih6Z1TlwcFVap+
-cTcDptoUvXYGg/9mRNNPZwErSfIJ0Ibnx9wPVuRN6NiCLOt2mtKp2F1pM6AOQPpZ
-85vEh6I8i6OaO0w/Z0UHBwvpY6jDUliaROsWUQsqz78Z34CVj4cy6vPW2EF4
-=r6KK
-----END PGP PUBLIC KEY BLOCK-----
-```
--- a/accounts/abi/abi.go
+++ b/accounts/abi/abi.go
@ -1,192 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// The ABI holds information about a contract's context and available
-// invokable methods. It will allow you to type check function calls and
-// packs data accordingly.
-type ABI struct {
-	Constructor Method
-	Methods     map[string]Method
-	Events      map[string]Event
-}
-
-// JSON returns a parsed ABI interface and error if it failed.
-func JSON(reader io.Reader) (ABI, error) {
-	dec := json.NewDecoder(reader)
-
-	var abi ABI
-	if err := dec.Decode(&abi); err != nil {
-		return ABI{}, err
-	}
-
-	return abi, nil
-}
-
-// Pack the given method name to conform the ABI. Method call's data
-// will consist of method_id, args0, arg1, ... argN. Method id consists
-// of 4 bytes and arguments are all 32 bytes.
-// Method ids are created from the first 4 bytes of the hash of the
-// methods string signature. (signature = baz(uint32,string32))
-func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
-	// Fetch the ABI of the requested method
-	if name == "" {
-		// constructor
-		arguments, err := abi.Constructor.Inputs.Pack(args...)
-		if err != nil {
-			return nil, err
-		}
-		return arguments, nil
-	}
-	method, exist := abi.Methods[name]
-	if !exist {
-		return nil, fmt.Errorf("method '%s' not found", name)
-	}
-	arguments, err := method.Inputs.Pack(args...)
-	if err != nil {
-		return nil, err
-	}
-	// Pack up the method ID too if not a constructor and return
-	return append(method.ID(), arguments...), nil
-}
-
-// Unpack output in v according to the abi specification
-func (abi ABI) Unpack(v interface{}, name string, data []byte) (err error) {
-	if len(data) == 0 {
-		return fmt.Errorf("abi: unmarshalling empty output")
-	}
-	// since there can't be naming collisions with contracts and events,
-	// we need to decide whether we're calling a method or an event
-	if method, ok := abi.Methods[name]; ok {
-		if len(data)%32 != 0 {
-			return fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
-		}
-		return method.Outputs.Unpack(v, data)
-	}
-	if event, ok := abi.Events[name]; ok {
-		return event.Inputs.Unpack(v, data)
-	}
-	return fmt.Errorf("abi: could not locate named method or event")
-}
-
-// UnpackIntoMap unpacks a log into the provided map[string]interface{}
-func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
-	if len(data) == 0 {
-		return fmt.Errorf("abi: unmarshalling empty output")
-	}
-	// since there can't be naming collisions with contracts and events,
-	// we need to decide whether we're calling a method or an event
-	if method, ok := abi.Methods[name]; ok {
-		if len(data)%32 != 0 {
-			return fmt.Errorf("abi: improperly formatted output")
-		}
-		return method.Outputs.UnpackIntoMap(v, data)
-	}
-	if event, ok := abi.Events[name]; ok {
-		return event.Inputs.UnpackIntoMap(v, data)
-	}
-	return fmt.Errorf("abi: could not locate named method or event")
-}
-
-// UnmarshalJSON implements json.Unmarshaler interface
-func (abi *ABI) UnmarshalJSON(data []byte) error {
-	var fields []struct {
-		Type      string
-		Name      string
-		Constant  bool
-		Anonymous bool
-		Inputs    []Argument
-		Outputs   []Argument
-	}
-	if err := json.Unmarshal(data, &fields); err != nil {
-		return err
-	}
-	abi.Methods = make(map[string]Method)
-	abi.Events = make(map[string]Event)
-	for _, field := range fields {
-		switch field.Type {
-		case "constructor":
-			abi.Constructor = Method{
-				Inputs: field.Inputs,
-			}
-		// empty defaults to function according to the abi spec
-		case "function", "":
-			name := field.Name
-			_, ok := abi.Methods[name]
-			for idx := 0; ok; idx++ {
-				name = fmt.Sprintf("%s%d", field.Name, idx)
-				_, ok = abi.Methods[name]
-			}
-			abi.Methods[name] = Method{
-				Name:    name,
-				RawName: field.Name,
-				Const:   field.Constant,
-				Inputs:  field.Inputs,
-				Outputs: field.Outputs,
-			}
-		case "event":
-			name := field.Name
-			_, ok := abi.Events[name]
-			for idx := 0; ok; idx++ {
-				name = fmt.Sprintf("%s%d", field.Name, idx)
-				_, ok = abi.Events[name]
-			}
-			abi.Events[name] = Event{
-				Name:      name,
-				RawName:   field.Name,
-				Anonymous: field.Anonymous,
-				Inputs:    field.Inputs,
-			}
-		}
-	}
-
-	return nil
-}
-
-// MethodById looks up a method by the 4-byte id
-// returns nil if none found
-func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
-	if len(sigdata) < 4 {
-		return nil, fmt.Errorf("data too short (%d bytes) for abi method lookup", len(sigdata))
-	}
-	for _, method := range abi.Methods {
-		if bytes.Equal(method.ID(), sigdata[:4]) {
-			return &method, nil
-		}
-	}
-	return nil, fmt.Errorf("no method with id: %#x", sigdata[:4])
-}
-
-// EventByID looks an event up by its topic hash in the
-// ABI and returns nil if none found.
-func (abi *ABI) EventByID(topic common.Hash) (*Event, error) {
-	for _, event := range abi.Events {
-		if bytes.Equal(event.ID().Bytes(), topic.Bytes()) {
-			return &event, nil
-		}
-	}
-	return nil, fmt.Errorf("no event with id: %#x", topic.Hex())
-}
--- a/accounts/abi/abi_test.go
+++ b/accounts/abi/abi_test.go
--- a/accounts/abi/bind/auth.go
+++ b/accounts/abi/bind/auth.go
@ -1,96 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind
-
-import (
-	"crypto/ecdsa"
-	"errors"
-	"io"
-	"io/ioutil"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/accounts/external"
-	"github.com/ethereum/go-ethereum/accounts/keystore"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// NewTransactor is a utility method to easily create a transaction signer from
-// an encrypted json key stream and the associated passphrase.
-func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
-	json, err := ioutil.ReadAll(keyin)
-	if err != nil {
-		return nil, err
-	}
-	key, err := keystore.DecryptKey(json, passphrase)
-	if err != nil {
-		return nil, err
-	}
-	return NewKeyedTransactor(key.PrivateKey), nil
-}
-
-// NewKeyStoreTransactor is a utility method to easily create a transaction signer from
-// an decrypted key from a keystore
-func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
-	return &TransactOpts{
-		From: account.Address,
-		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
-			if address != account.Address {
-				return nil, errors.New("not authorized to sign this account")
-			}
-			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
-			if err != nil {
-				return nil, err
-			}
-			return tx.WithSignature(signer, signature)
-		},
-	}, nil
-}
-
-// NewKeyedTransactor is a utility method to easily create a transaction signer
-// from a single private key.
-func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
-	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
-	return &TransactOpts{
-		From: keyAddr,
-		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
-			if address != keyAddr {
-				return nil, errors.New("not authorized to sign this account")
-			}
-			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
-			if err != nil {
-				return nil, err
-			}
-			return tx.WithSignature(signer, signature)
-		},
-	}
-}
-
-// NewClefTransactor is a utility method to easily create a transaction signer
-// with a clef backend.
-func NewClefTransactor(clef *external.ExternalSigner, account accounts.Account) *TransactOpts {
-	return &TransactOpts{
-		From: account.Address,
-		Signer: func(signer types.Signer, address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
-			if address != account.Address {
-				return nil, errors.New("not authorized to sign this account")
-			}
-			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
-		},
-	}
-}
--- a/accounts/abi/bind/backends/simulated_test.go
+++ b/accounts/abi/bind/backends/simulated_test.go
@ -1,83 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package backends_test
-
-import (
-	"context"
-	"math/big"
-	"testing"
-
-	ethereum "github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-func TestSimulatedBackend(t *testing.T) {
-	var gasLimit uint64 = 8000029
-	key, _ := crypto.GenerateKey() // nolint: gosec
-	auth := bind.NewKeyedTransactor(key)
-	genAlloc := make(core.GenesisAlloc)
-	genAlloc[auth.From] = core.GenesisAccount{Balance: big.NewInt(9223372036854775807)}
-
-	sim := backends.NewSimulatedBackend(genAlloc, gasLimit)
-	defer sim.Close()
-
-	// should return an error if the tx is not found
-	txHash := common.HexToHash("2")
-	_, isPending, err := sim.TransactionByHash(context.Background(), txHash)
-
-	if isPending {
-		t.Fatal("transaction should not be pending")
-	}
-	if err != ethereum.NotFound {
-		t.Fatalf("err should be `ethereum.NotFound` but received %v", err)
-	}
-
-	// generate a transaction and confirm you can retrieve it
-	code := `6060604052600a8060106000396000f360606040526008565b00`
-	var gas uint64 = 3000000
-	tx := types.NewContractCreation(0, big.NewInt(0), gas, big.NewInt(1), common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, key)
-
-	err = sim.SendTransaction(context.Background(), tx)
-	if err != nil {
-		t.Fatal("error sending transaction")
-	}
-
-	txHash = tx.Hash()
-	_, isPending, err = sim.TransactionByHash(context.Background(), txHash)
-	if err != nil {
-		t.Fatalf("error getting transaction with hash: %v", txHash.String())
-	}
-	if !isPending {
-		t.Fatal("transaction should have pending status")
-	}
-
-	sim.Commit()
-	tx, isPending, err = sim.TransactionByHash(context.Background(), txHash)
-	if err != nil {
-		t.Fatalf("error getting transaction with hash: %v", txHash.String())
-	}
-	if isPending {
-		t.Fatal("transaction should not have pending status")
-	}
-
-}
--- a/accounts/abi/bind/base.go
+++ b/accounts/abi/bind/base.go
@ -1,366 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-// SignerFn is a signer function callback when a contract requires a method to
-// sign the transaction before submission.
-type SignerFn func(types.Signer, common.Address, *types.Transaction) (*types.Transaction, error)
-
-// CallOpts is the collection of options to fine tune a contract call request.
-type CallOpts struct {
-	Pending     bool            // Whether to operate on the pending state or the last known one
-	From        common.Address  // Optional the sender address, otherwise the first account is used
-	BlockNumber *big.Int        // Optional the block number on which the call should be performed
-	Context     context.Context // Network context to support cancellation and timeouts (nil = no timeout)
-}
-
-// TransactOpts is the collection of authorization data required to create a
-// valid Ethereum transaction.
-type TransactOpts struct {
-	From   common.Address // Ethereum account to send the transaction from
-	Nonce  *big.Int       // Nonce to use for the transaction execution (nil = use pending state)
-	Signer SignerFn       // Method to use for signing the transaction (mandatory)
-
-	Value    *big.Int // Funds to transfer along along the transaction (nil = 0 = no funds)
-	GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle)
-	GasLimit uint64   // Gas limit to set for the transaction execution (0 = estimate)
-
-	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
-}
-
-// FilterOpts is the collection of options to fine tune filtering for events
-// within a bound contract.
-type FilterOpts struct {
-	Start uint64  // Start of the queried range
-	End   *uint64 // End of the range (nil = latest)
-
-	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
-}
-
-// WatchOpts is the collection of options to fine tune subscribing for events
-// within a bound contract.
-type WatchOpts struct {
-	Start   *uint64         // Start of the queried range (nil = latest)
-	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
-}
-
-// BoundContract is the base wrapper object that reflects a contract on the
-// Ethereum network. It contains a collection of methods that are used by the
-// higher level contract bindings to operate.
-type BoundContract struct {
-	address    common.Address     // Deployment address of the contract on the Ethereum blockchain
-	abi        abi.ABI            // Reflect based ABI to access the correct Ethereum methods
-	caller     ContractCaller     // Read interface to interact with the blockchain
-	transactor ContractTransactor // Write interface to interact with the blockchain
-	filterer   ContractFilterer   // Event filtering to interact with the blockchain
-}
-
-// NewBoundContract creates a low level contract interface through which calls
-// and transactions may be made through.
-func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller, transactor ContractTransactor, filterer ContractFilterer) *BoundContract {
-	return &BoundContract{
-		address:    address,
-		abi:        abi,
-		caller:     caller,
-		transactor: transactor,
-		filterer:   filterer,
-	}
-}
-
-// DeployContract deploys a contract onto the Ethereum blockchain and binds the
-// deployment address with a Go wrapper.
-func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend ContractBackend, params ...interface{}) (common.Address, *types.Transaction, *BoundContract, error) {
-	// Otherwise try to deploy the contract
-	c := NewBoundContract(common.Address{}, abi, backend, backend, backend)
-
-	input, err := c.abi.Pack("", params...)
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	tx, err := c.transact(opts, nil, append(bytecode, input...))
-	if err != nil {
-		return common.Address{}, nil, nil, err
-	}
-	c.address = crypto.CreateAddress(opts.From, tx.Nonce())
-	return c.address, tx, c, nil
-}
-
-// Call invokes the (constant) contract method with params as input values and
-// sets the output to result. The result type might be a single field for simple
-// returns, a slice of interfaces for anonymous returns and a struct for named
-// returns.
-func (c *BoundContract) Call(opts *CallOpts, result interface{}, method string, params ...interface{}) error {
-	// Don't crash on a lazy user
-	if opts == nil {
-		opts = new(CallOpts)
-	}
-	// Pack the input, call and unpack the results
-	input, err := c.abi.Pack(method, params...)
-	if err != nil {
-		return err
-	}
-	var (
-		msg    = ethereum.CallMsg{From: opts.From, To: &c.address, Data: input}
-		ctx    = ensureContext(opts.Context)
-		code   []byte
-		output []byte
-	)
-	if opts.Pending {
-		pb, ok := c.caller.(PendingContractCaller)
-		if !ok {
-			return ErrNoPendingState
-		}
-		output, err = pb.PendingCallContract(ctx, msg)
-		if err == nil && len(output) == 0 {
-			// Make sure we have a contract to operate on, and bail out otherwise.
-			if code, err = pb.PendingCodeAt(ctx, c.address); err != nil {
-				return err
-			} else if len(code) == 0 {
-				return ErrNoCode
-			}
-		}
-	} else {
-		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
-		if err == nil && len(output) == 0 {
-			// Make sure we have a contract to operate on, and bail out otherwise.
-			if code, err = c.caller.CodeAt(ctx, c.address, opts.BlockNumber); err != nil {
-				return err
-			} else if len(code) == 0 {
-				return ErrNoCode
-			}
-		}
-	}
-	if err != nil {
-		return err
-	}
-	return c.abi.Unpack(result, method, output)
-}
-
-// Transact invokes the (paid) contract method with params as input values.
-func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-	// Otherwise pack up the parameters and invoke the contract
-	input, err := c.abi.Pack(method, params...)
-	if err != nil {
-		return nil, err
-	}
-	return c.transact(opts, &c.address, input)
-}
-
-// Transfer initiates a plain transaction to move funds to the contract, calling
-// its default method if one is available.
-func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error) {
-	return c.transact(opts, &c.address, nil)
-}
-
-// transact executes an actual transaction invocation, first deriving any missing
-// authorization fields, and then scheduling the transaction for execution.
-func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
-	var err error
-
-	// Ensure a valid value field and resolve the account nonce
-	value := opts.Value
-	if value == nil {
-		value = new(big.Int)
-	}
-	var nonce uint64
-	if opts.Nonce == nil {
-		nonce, err = c.transactor.PendingNonceAt(ensureContext(opts.Context), opts.From)
-		if err != nil {
-			return nil, fmt.Errorf("failed to retrieve account nonce: %v", err)
-		}
-	} else {
-		nonce = opts.Nonce.Uint64()
-	}
-	// Figure out the gas allowance and gas price values
-	gasPrice := opts.GasPrice
-	if gasPrice == nil {
-		gasPrice, err = c.transactor.SuggestGasPrice(ensureContext(opts.Context))
-		if err != nil {
-			return nil, fmt.Errorf("failed to suggest gas price: %v", err)
-		}
-	}
-	gasLimit := opts.GasLimit
-	if gasLimit == 0 {
-		// Gas estimation cannot succeed without code for method invocations
-		if contract != nil {
-			if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil {
-				return nil, err
-			} else if len(code) == 0 {
-				return nil, ErrNoCode
-			}
-		}
-		// If the contract surely has code (or code is not needed), estimate the transaction
-		msg := ethereum.CallMsg{From: opts.From, To: contract, Value: value, Data: input}
-		gasLimit, err = c.transactor.EstimateGas(ensureContext(opts.Context), msg)
-		if err != nil {
-			return nil, fmt.Errorf("failed to estimate gas needed: %v", err)
-		}
-	}
-	// Create the transaction, sign it and schedule it for execution
-	var rawTx *types.Transaction
-	if contract == nil {
-		rawTx = types.NewContractCreation(nonce, value, gasLimit, gasPrice, input)
-	} else {
-		rawTx = types.NewTransaction(nonce, c.address, value, gasLimit, gasPrice, input)
-	}
-	if opts.Signer == nil {
-		return nil, errors.New("no signer to authorize the transaction with")
-	}
-	signedTx, err := opts.Signer(types.HomesteadSigner{}, opts.From, rawTx)
-	if err != nil {
-		return nil, err
-	}
-	if err := c.transactor.SendTransaction(ensureContext(opts.Context), signedTx); err != nil {
-		return nil, err
-	}
-	return signedTx, nil
-}
-
-// FilterLogs filters contract logs for past blocks, returning the necessary
-// channels to construct a strongly typed bound iterator on top of them.
-func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
-	// Don't crash on a lazy user
-	if opts == nil {
-		opts = new(FilterOpts)
-	}
-	// Append the event selector to the query parameters and construct the topic set
-	query = append([][]interface{}{{c.abi.Events[name].ID()}}, query...)
-
-	topics, err := makeTopics(query...)
-	if err != nil {
-		return nil, nil, err
-	}
-	// Start the background filtering
-	logs := make(chan types.Log, 128)
-
-	config := ethereum.FilterQuery{
-		Addresses: []common.Address{c.address},
-		Topics:    topics,
-		FromBlock: new(big.Int).SetUint64(opts.Start),
-	}
-	if opts.End != nil {
-		config.ToBlock = new(big.Int).SetUint64(*opts.End)
-	}
-	/* TODO(karalabe): Replace the rest of the method below with this when supported
-	sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs)
-	*/
-	buff, err := c.filterer.FilterLogs(ensureContext(opts.Context), config)
-	if err != nil {
-		return nil, nil, err
-	}
-	sub, err := event.NewSubscription(func(quit <-chan struct{}) error {
-		for _, log := range buff {
-			select {
-			case logs <- log:
-			case <-quit:
-				return nil
-			}
-		}
-		return nil
-	}), nil
-
-	if err != nil {
-		return nil, nil, err
-	}
-	return logs, sub, nil
-}
-
-// WatchLogs filters subscribes to contract logs for future blocks, returning a
-// subscription object that can be used to tear down the watcher.
-func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
-	// Don't crash on a lazy user
-	if opts == nil {
-		opts = new(WatchOpts)
-	}
-	// Append the event selector to the query parameters and construct the topic set
-	query = append([][]interface{}{{c.abi.Events[name].ID()}}, query...)
-
-	topics, err := makeTopics(query...)
-	if err != nil {
-		return nil, nil, err
-	}
-	// Start the background filtering
-	logs := make(chan types.Log, 128)
-
-	config := ethereum.FilterQuery{
-		Addresses: []common.Address{c.address},
-		Topics:    topics,
-	}
-	if opts.Start != nil {
-		config.FromBlock = new(big.Int).SetUint64(*opts.Start)
-	}
-	sub, err := c.filterer.SubscribeFilterLogs(ensureContext(opts.Context), config, logs)
-	if err != nil {
-		return nil, nil, err
-	}
-	return logs, sub, nil
-}
-
-// UnpackLog unpacks a retrieved log into the provided output structure.
-func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log) error {
-	if len(log.Data) > 0 {
-		if err := c.abi.Unpack(out, event, log.Data); err != nil {
-			return err
-		}
-	}
-	var indexed abi.Arguments
-	for _, arg := range c.abi.Events[event].Inputs {
-		if arg.Indexed {
-			indexed = append(indexed, arg)
-		}
-	}
-	return parseTopics(out, indexed, log.Topics[1:])
-}
-
-// UnpackLogIntoMap unpacks a retrieved log into the provided map.
-func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error {
-	if len(log.Data) > 0 {
-		if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil {
-			return err
-		}
-	}
-	var indexed abi.Arguments
-	for _, arg := range c.abi.Events[event].Inputs {
-		if arg.Indexed {
-			indexed = append(indexed, arg)
-		}
-	}
-	return parseTopicsIntoMap(out, indexed, log.Topics[1:])
-}
-
-// ensureContext is a helper method to ensure a context is not nil, even if the
-// user specified it as such.
-func ensureContext(ctx context.Context) context.Context {
-	if ctx == nil {
-		return context.TODO()
-	}
-	return ctx
-}
--- a/accounts/abi/bind/base_test.go
+++ b/accounts/abi/bind/base_test.go
@ -1,347 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind_test
-
-import (
-	"bytes"
-	"context"
-	"math/big"
-	"strings"
-	"testing"
-
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/rlp"
-)
-
-type mockCaller struct {
-	codeAtBlockNumber       *big.Int
-	callContractBlockNumber *big.Int
-}
-
-func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
-	mc.codeAtBlockNumber = blockNumber
-	return []byte{1, 2, 3}, nil
-}
-
-func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
-	mc.callContractBlockNumber = blockNumber
-	return nil, nil
-}
-func TestPassingBlockNumber(t *testing.T) {
-
-	mc := &mockCaller{}
-
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
-		Methods: map[string]abi.Method{
-			"something": {
-				Name:    "something",
-				Outputs: abi.Arguments{},
-			},
-		},
-	}, mc, nil, nil)
-	var ret string
-
-	blockNumber := big.NewInt(42)
-
-	bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something")
-
-	if mc.callContractBlockNumber != blockNumber {
-		t.Fatalf("CallContract() was not passed the block number")
-	}
-
-	if mc.codeAtBlockNumber != blockNumber {
-		t.Fatalf("CodeAt() was not passed the block number")
-	}
-
-	bc.Call(&bind.CallOpts{}, &ret, "something")
-
-	if mc.callContractBlockNumber != nil {
-		t.Fatalf("CallContract() was passed a block number when it should not have been")
-	}
-
-	if mc.codeAtBlockNumber != nil {
-		t.Fatalf("CodeAt() was passed a block number when it should not have been")
-	}
-}
-
-const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158"
-
-func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
-	hash := crypto.Keccak256Hash([]byte("testName"))
-	mockLog := types.Log{
-		Address: common.HexToAddress("0x0"),
-		Topics: []common.Hash{
-			common.HexToHash("0x0"),
-			hash,
-		},
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      common.HexToHash("0x0"),
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
-
-	abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"name","type":"string"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
-	parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
-	receivedMap := make(map[string]interface{})
-	expectedReceivedMap := map[string]interface{}{
-		"name":   hash,
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	if err := bc.UnpackLogIntoMap(receivedMap, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(receivedMap) != 4 {
-		t.Fatal("unpacked map expected to have length 4")
-	}
-	if receivedMap["name"] != expectedReceivedMap["name"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked map does not match expected map")
-	}
-}
-
-func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
-	sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	hash := crypto.Keccak256Hash(sliceBytes)
-	mockLog := types.Log{
-		Address: common.HexToAddress("0x0"),
-		Topics: []common.Hash{
-			common.HexToHash("0x0"),
-			hash,
-		},
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      common.HexToHash("0x0"),
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
-
-	abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"names","type":"string[]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
-	parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
-	receivedMap := make(map[string]interface{})
-	expectedReceivedMap := map[string]interface{}{
-		"names":  hash,
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	if err := bc.UnpackLogIntoMap(receivedMap, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(receivedMap) != 4 {
-		t.Fatal("unpacked map expected to have length 4")
-	}
-	if receivedMap["names"] != expectedReceivedMap["names"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked map does not match expected map")
-	}
-}
-
-func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
-	arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")})
-	if err != nil {
-		t.Fatal(err)
-	}
-	hash := crypto.Keccak256Hash(arrBytes)
-	mockLog := types.Log{
-		Address: common.HexToAddress("0x0"),
-		Topics: []common.Hash{
-			common.HexToHash("0x0"),
-			hash,
-		},
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      common.HexToHash("0x0"),
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
-
-	abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"addresses","type":"address[2]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
-	parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
-	receivedMap := make(map[string]interface{})
-	expectedReceivedMap := map[string]interface{}{
-		"addresses": hash,
-		"sender":    common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":    big.NewInt(1),
-		"memo":      []byte{88},
-	}
-	if err := bc.UnpackLogIntoMap(receivedMap, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(receivedMap) != 4 {
-		t.Fatal("unpacked map expected to have length 4")
-	}
-	if receivedMap["addresses"] != expectedReceivedMap["addresses"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked map does not match expected map")
-	}
-}
-
-func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
-	mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")
-	addrBytes := mockAddress.Bytes()
-	hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)"))
-	functionSelector := hash[:4]
-	functionTyBytes := append(addrBytes, functionSelector...)
-	var functionTy [24]byte
-	copy(functionTy[:], functionTyBytes[0:24])
-	mockLog := types.Log{
-		Address: common.HexToAddress("0x0"),
-		Topics: []common.Hash{
-			common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
-			common.BytesToHash(functionTyBytes),
-		},
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"),
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
-
-	abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"function","type":"function"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
-	parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
-	receivedMap := make(map[string]interface{})
-	expectedReceivedMap := map[string]interface{}{
-		"function": functionTy,
-		"sender":   common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":   big.NewInt(1),
-		"memo":     []byte{88},
-	}
-	if err := bc.UnpackLogIntoMap(receivedMap, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(receivedMap) != 4 {
-		t.Fatal("unpacked map expected to have length 4")
-	}
-	if receivedMap["function"] != expectedReceivedMap["function"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked map does not match expected map")
-	}
-}
-
-func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
-	byts := []byte{1, 2, 3, 4, 5}
-	hash := crypto.Keccak256Hash(byts)
-	mockLog := types.Log{
-		Address: common.HexToAddress("0x0"),
-		Topics: []common.Hash{
-			common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
-			hash,
-		},
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"),
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
-
-	abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"content","type":"bytes"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
-	parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
-	bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
-
-	receivedMap := make(map[string]interface{})
-	expectedReceivedMap := map[string]interface{}{
-		"content": hash,
-		"sender":  common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":  big.NewInt(1),
-		"memo":    []byte{88},
-	}
-	if err := bc.UnpackLogIntoMap(receivedMap, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(receivedMap) != 4 {
-		t.Fatal("unpacked map expected to have length 4")
-	}
-	if receivedMap["content"] != expectedReceivedMap["content"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked map does not match expected map")
-	}
-}
--- a/accounts/abi/bind/bind.go
+++ b/accounts/abi/bind/bind.go
@ -1,558 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package bind generates Ethereum contract Go bindings.
-//
-// Detailed usage document and tutorial available on the go-ethereum Wiki page:
-// https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts
-package bind
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"go/format"
-	"regexp"
-	"strings"
-	"text/template"
-	"unicode"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// Lang is a target programming language selector to generate bindings for.
-type Lang int
-
-const (
-	LangGo Lang = iota
-	LangJava
-	LangObjC
-)
-
-// Bind generates a Go wrapper around a contract ABI. This wrapper isn't meant
-// to be used as is in client code, but rather as an intermediate struct which
-// enforces compile time type safety and naming convention opposed to having to
-// manually maintain hard coded strings that break on runtime.
-func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]string, pkg string, lang Lang, libs map[string]string) (string, error) {
-	// Process each individual contract requested binding
-	contracts := make(map[string]*tmplContract)
-
-	// Map used to flag each encountered library as such
-	isLib := make(map[string]struct{})
-
-	for i := 0; i < len(types); i++ {
-		// Parse the actual ABI to generate the binding for
-		evmABI, err := abi.JSON(strings.NewReader(abis[i]))
-		if err != nil {
-			return "", err
-		}
-		// Strip any whitespace from the JSON ABI
-		strippedABI := strings.Map(func(r rune) rune {
-			if unicode.IsSpace(r) {
-				return -1
-			}
-			return r
-		}, abis[i])
-
-		// Extract the call and transact methods; events, struct definitions; and sort them alphabetically
-		var (
-			calls     = make(map[string]*tmplMethod)
-			transacts = make(map[string]*tmplMethod)
-			events    = make(map[string]*tmplEvent)
-			structs   = make(map[string]*tmplStruct)
-		)
-		for _, original := range evmABI.Methods {
-			// Normalize the method for capital cases and non-anonymous inputs/outputs
-			normalized := original
-			normalized.Name = methodNormalizer[lang](original.Name)
-
-			normalized.Inputs = make([]abi.Argument, len(original.Inputs))
-			copy(normalized.Inputs, original.Inputs)
-			for j, input := range normalized.Inputs {
-				if input.Name == "" {
-					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
-				}
-				if _, exist := structs[input.Type.String()]; input.Type.T == abi.TupleTy && !exist {
-					bindStructType[lang](input.Type, structs)
-				}
-			}
-			normalized.Outputs = make([]abi.Argument, len(original.Outputs))
-			copy(normalized.Outputs, original.Outputs)
-			for j, output := range normalized.Outputs {
-				if output.Name != "" {
-					normalized.Outputs[j].Name = capitalise(output.Name)
-				}
-				if _, exist := structs[output.Type.String()]; output.Type.T == abi.TupleTy && !exist {
-					bindStructType[lang](output.Type, structs)
-				}
-			}
-			// Append the methods to the call or transact lists
-			if original.Const {
-				calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
-			} else {
-				transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
-			}
-		}
-		for _, original := range evmABI.Events {
-			// Skip anonymous events as they don't support explicit filtering
-			if original.Anonymous {
-				continue
-			}
-			// Normalize the event for capital cases and non-anonymous outputs
-			normalized := original
-			normalized.Name = methodNormalizer[lang](original.Name)
-
-			normalized.Inputs = make([]abi.Argument, len(original.Inputs))
-			copy(normalized.Inputs, original.Inputs)
-			for j, input := range normalized.Inputs {
-				// Indexed fields are input, non-indexed ones are outputs
-				if input.Indexed {
-					if input.Name == "" {
-						normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
-					}
-					if _, exist := structs[input.Type.String()]; input.Type.T == abi.TupleTy && !exist {
-						bindStructType[lang](input.Type, structs)
-					}
-				}
-			}
-			// Append the event to the accumulator list
-			events[original.Name] = &tmplEvent{Original: original, Normalized: normalized}
-		}
-
-		// There is no easy way to pass arbitrary java objects to the Go side.
-		if len(structs) > 0 && lang == LangJava {
-			return "", errors.New("java binding for tuple arguments is not supported yet")
-		}
-
-		contracts[types[i]] = &tmplContract{
-			Type:        capitalise(types[i]),
-			InputABI:    strings.Replace(strippedABI, "\"", "\\\"", -1),
-			InputBin:    strings.TrimPrefix(strings.TrimSpace(bytecodes[i]), "0x"),
-			Constructor: evmABI.Constructor,
-			Calls:       calls,
-			Transacts:   transacts,
-			Events:      events,
-			Libraries:   make(map[string]string),
-			Structs:     structs,
-		}
-		// Function 4-byte signatures are stored in the same sequence
-		// as types, if available.
-		if len(fsigs) > i {
-			contracts[types[i]].FuncSigs = fsigs[i]
-		}
-		// Parse library references.
-		for pattern, name := range libs {
-			matched, err := regexp.Match("__\\$"+pattern+"\\$__", []byte(contracts[types[i]].InputBin))
-			if err != nil {
-				log.Error("Could not search for pattern", "pattern", pattern, "contract", contracts[types[i]], "err", err)
-			}
-			if matched {
-				contracts[types[i]].Libraries[pattern] = name
-				// keep track that this type is a library
-				if _, ok := isLib[name]; !ok {
-					isLib[name] = struct{}{}
-				}
-			}
-		}
-	}
-	// Check if that type has already been identified as a library
-	for i := 0; i < len(types); i++ {
-		_, ok := isLib[types[i]]
-		contracts[types[i]].Library = ok
-	}
-	// Generate the contract template data content and render it
-	data := &tmplData{
-		Package:   pkg,
-		Contracts: contracts,
-		Libraries: libs,
-	}
-	buffer := new(bytes.Buffer)
-
-	funcs := map[string]interface{}{
-		"bindtype":      bindType[lang],
-		"bindtopictype": bindTopicType[lang],
-		"namedtype":     namedType[lang],
-		"formatmethod":  formatMethod,
-		"formatevent":   formatEvent,
-		"capitalise":    capitalise,
-		"decapitalise":  decapitalise,
-	}
-	tmpl := template.Must(template.New("").Funcs(funcs).Parse(tmplSource[lang]))
-	if err := tmpl.Execute(buffer, data); err != nil {
-		return "", err
-	}
-	// For Go bindings pass the code through gofmt to clean it up
-	if lang == LangGo {
-		code, err := format.Source(buffer.Bytes())
-		if err != nil {
-			return "", fmt.Errorf("%v\n%s", err, buffer)
-		}
-		return string(code), nil
-	}
-	// For all others just return as is for now
-	return buffer.String(), nil
-}
-
-// bindType is a set of type binders that convert Solidity types to some supported
-// programming language types.
-var bindType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo:   bindTypeGo,
-	LangJava: bindTypeJava,
-}
-
-// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go one.
-func bindBasicTypeGo(kind abi.Type) string {
-	switch kind.T {
-	case abi.AddressTy:
-		return "common.Address"
-	case abi.IntTy, abi.UintTy:
-		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
-		switch parts[2] {
-		case "8", "16", "32", "64":
-			return fmt.Sprintf("%sint%s", parts[1], parts[2])
-		}
-		return "*big.Int"
-	case abi.FixedBytesTy:
-		return fmt.Sprintf("[%d]byte", kind.Size)
-	case abi.BytesTy:
-		return "[]byte"
-	case abi.FunctionTy:
-		return "[24]byte"
-	default:
-		// string, bool types
-		return kind.String()
-	}
-}
-
-// bindTypeGo converts solidity types to Go ones. Since there is no clear mapping
-// from all Solidity types to Go ones (e.g. uint17), those that cannot be exactly
-// mapped will use an upscaled type (e.g. BigDecimal).
-func bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
-	switch kind.T {
-	case abi.TupleTy:
-		return structs[kind.String()].Name
-	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindTypeGo(*kind.Elem, structs)
-	case abi.SliceTy:
-		return "[]" + bindTypeGo(*kind.Elem, structs)
-	default:
-		return bindBasicTypeGo(kind)
-	}
-}
-
-// bindBasicTypeJava converts basic solidity types(except array, slice and tuple) to Java one.
-func bindBasicTypeJava(kind abi.Type) string {
-	switch kind.T {
-	case abi.AddressTy:
-		return "Address"
-	case abi.IntTy, abi.UintTy:
-		// Note that uint and int (without digits) are also matched,
-		// these are size 256, and will translate to BigInt (the default).
-		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(kind.String())
-		if len(parts) != 3 {
-			return kind.String()
-		}
-		// All unsigned integers should be translated to BigInt since gomobile doesn't
-		// support them.
-		if parts[1] == "u" {
-			return "BigInt"
-		}
-
-		namedSize := map[string]string{
-			"8":  "byte",
-			"16": "short",
-			"32": "int",
-			"64": "long",
-		}[parts[2]]
-
-		// default to BigInt
-		if namedSize == "" {
-			namedSize = "BigInt"
-		}
-		return namedSize
-	case abi.FixedBytesTy, abi.BytesTy:
-		return "byte[]"
-	case abi.BoolTy:
-		return "boolean"
-	case abi.StringTy:
-		return "String"
-	case abi.FunctionTy:
-		return "byte[24]"
-	default:
-		return kind.String()
-	}
-}
-
-// pluralizeJavaType explicitly converts multidimensional types to predefined
-// type in go side.
-func pluralizeJavaType(typ string) string {
-	switch typ {
-	case "boolean":
-		return "Bools"
-	case "String":
-		return "Strings"
-	case "Address":
-		return "Addresses"
-	case "byte[]":
-		return "Binaries"
-	case "BigInt":
-		return "BigInts"
-	}
-	return typ + "[]"
-}
-
-// bindTypeJava converts a Solidity type to a Java one. Since there is no clear mapping
-// from all Solidity types to Java ones (e.g. uint17), those that cannot be exactly
-// mapped will use an upscaled type (e.g. BigDecimal).
-func bindTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
-	switch kind.T {
-	case abi.TupleTy:
-		return structs[kind.String()].Name
-	case abi.ArrayTy, abi.SliceTy:
-		return pluralizeJavaType(bindTypeJava(*kind.Elem, structs))
-	default:
-		return bindBasicTypeJava(kind)
-	}
-}
-
-// bindTopicType is a set of type binders that convert Solidity types to some
-// supported programming language topic types.
-var bindTopicType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo:   bindTopicTypeGo,
-	LangJava: bindTopicTypeJava,
-}
-
-// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same
-// funcionality as for simple types, but dynamic types get converted to hashes.
-func bindTopicTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
-	bound := bindTypeGo(kind, structs)
-	if bound == "string" || bound == "[]byte" {
-		bound = "common.Hash"
-	}
-	return bound
-}
-
-// bindTopicTypeJava converts a Solidity topic type to a Java one. It is almost the same
-// funcionality as for simple types, but dynamic types get converted to hashes.
-func bindTopicTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
-	bound := bindTypeJava(kind, structs)
-	if bound == "String" || bound == "byte[]" {
-		bound = "Hash"
-	}
-	return bound
-}
-
-// bindStructType is a set of type binders that convert Solidity tuple types to some supported
-// programming language struct definition.
-var bindStructType = map[Lang]func(kind abi.Type, structs map[string]*tmplStruct) string{
-	LangGo:   bindStructTypeGo,
-	LangJava: bindStructTypeJava,
-}
-
-// bindStructTypeGo converts a Solidity tuple type to a Go one and records the mapping
-// in the given map.
-// Notably, this function will resolve and record nested struct recursively.
-func bindStructTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
-	switch kind.T {
-	case abi.TupleTy:
-		if s, exist := structs[kind.String()]; exist {
-			return s.Name
-		}
-		var fields []*tmplField
-		for i, elem := range kind.TupleElems {
-			field := bindStructTypeGo(*elem, structs)
-			fields = append(fields, &tmplField{Type: field, Name: capitalise(kind.TupleRawNames[i]), SolKind: *elem})
-		}
-		name := fmt.Sprintf("Struct%d", len(structs))
-		structs[kind.String()] = &tmplStruct{
-			Name:   name,
-			Fields: fields,
-		}
-		return name
-	case abi.ArrayTy:
-		return fmt.Sprintf("[%d]", kind.Size) + bindStructTypeGo(*kind.Elem, structs)
-	case abi.SliceTy:
-		return "[]" + bindStructTypeGo(*kind.Elem, structs)
-	default:
-		return bindBasicTypeGo(kind)
-	}
-}
-
-// bindStructTypeJava converts a Solidity tuple type to a Java one and records the mapping
-// in the given map.
-// Notably, this function will resolve and record nested struct recursively.
-func bindStructTypeJava(kind abi.Type, structs map[string]*tmplStruct) string {
-	switch kind.T {
-	case abi.TupleTy:
-		if s, exist := structs[kind.String()]; exist {
-			return s.Name
-		}
-		var fields []*tmplField
-		for i, elem := range kind.TupleElems {
-			field := bindStructTypeJava(*elem, structs)
-			fields = append(fields, &tmplField{Type: field, Name: decapitalise(kind.TupleRawNames[i]), SolKind: *elem})
-		}
-		name := fmt.Sprintf("Class%d", len(structs))
-		structs[kind.String()] = &tmplStruct{
-			Name:   name,
-			Fields: fields,
-		}
-		return name
-	case abi.ArrayTy, abi.SliceTy:
-		return pluralizeJavaType(bindStructTypeJava(*kind.Elem, structs))
-	default:
-		return bindBasicTypeJava(kind)
-	}
-}
-
-// namedType is a set of functions that transform language specific types to
-// named versions that my be used inside method names.
-var namedType = map[Lang]func(string, abi.Type) string{
-	LangGo:   func(string, abi.Type) string { panic("this shouldn't be needed") },
-	LangJava: namedTypeJava,
-}
-
-// namedTypeJava converts some primitive data types to named variants that can
-// be used as parts of method names.
-func namedTypeJava(javaKind string, solKind abi.Type) string {
-	switch javaKind {
-	case "byte[]":
-		return "Binary"
-	case "boolean":
-		return "Bool"
-	default:
-		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
-		if len(parts) != 4 {
-			return javaKind
-		}
-		switch parts[2] {
-		case "8", "16", "32", "64":
-			if parts[3] == "" {
-				return capitalise(fmt.Sprintf("%sint%s", parts[1], parts[2]))
-			}
-			return capitalise(fmt.Sprintf("%sint%ss", parts[1], parts[2]))
-
-		default:
-			return javaKind
-		}
-	}
-}
-
-// methodNormalizer is a name transformer that modifies Solidity method names to
-// conform to target language naming concentions.
-var methodNormalizer = map[Lang]func(string) string{
-	LangGo:   abi.ToCamelCase,
-	LangJava: decapitalise,
-}
-
-// capitalise makes a camel-case string which starts with an upper case character.
-func capitalise(input string) string {
-	return abi.ToCamelCase(input)
-}
-
-// decapitalise makes a camel-case string which starts with a lower case character.
-func decapitalise(input string) string {
-	if len(input) == 0 {
-		return input
-	}
-
-	goForm := abi.ToCamelCase(input)
-	return strings.ToLower(goForm[:1]) + goForm[1:]
-}
-
-// structured checks whether a list of ABI data types has enough information to
-// operate through a proper Go struct or if flat returns are needed.
-func structured(args abi.Arguments) bool {
-	if len(args) < 2 {
-		return false
-	}
-	exists := make(map[string]bool)
-	for _, out := range args {
-		// If the name is anonymous, we can't organize into a struct
-		if out.Name == "" {
-			return false
-		}
-		// If the field name is empty when normalized or collides (var, Var, _var, _Var),
-		// we can't organize into a struct
-		field := capitalise(out.Name)
-		if field == "" || exists[field] {
-			return false
-		}
-		exists[field] = true
-	}
-	return true
-}
-
-// resolveArgName converts a raw argument representation into a user friendly format.
-func resolveArgName(arg abi.Argument, structs map[string]*tmplStruct) string {
-	var (
-		prefix   string
-		embedded string
-		typ      = &arg.Type
-	)
-loop:
-	for {
-		switch typ.T {
-		case abi.SliceTy:
-			prefix += "[]"
-		case abi.ArrayTy:
-			prefix += fmt.Sprintf("[%d]", typ.Size)
-		default:
-			embedded = typ.String()
-			break loop
-		}
-		typ = typ.Elem
-	}
-	if s, exist := structs[embedded]; exist {
-		return prefix + s.Name
-	} else {
-		return arg.Type.String()
-	}
-}
-
-// formatMethod transforms raw method representation into a user friendly one.
-func formatMethod(method abi.Method, structs map[string]*tmplStruct) string {
-	inputs := make([]string, len(method.Inputs))
-	for i, input := range method.Inputs {
-		inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name)
-	}
-	outputs := make([]string, len(method.Outputs))
-	for i, output := range method.Outputs {
-		outputs[i] = resolveArgName(output, structs)
-		if len(output.Name) > 0 {
-			outputs[i] += fmt.Sprintf(" %v", output.Name)
-		}
-	}
-	constant := ""
-	if method.Const {
-		constant = "constant "
-	}
-	return fmt.Sprintf("function %v(%v) %sreturns(%v)", method.RawName, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", "))
-}
-
-// formatEvent transforms raw event representation into a user friendly one.
-func formatEvent(event abi.Event, structs map[string]*tmplStruct) string {
-	inputs := make([]string, len(event.Inputs))
-	for i, input := range event.Inputs {
-		if input.Indexed {
-			inputs[i] = fmt.Sprintf("%v indexed %v", resolveArgName(input, structs), input.Name)
-		} else {
-			inputs[i] = fmt.Sprintf("%v %v", resolveArgName(input, structs), input.Name)
-		}
-	}
-	return fmt.Sprintf("event %v(%v)", event.RawName, strings.Join(inputs, ", "))
-}
--- a/accounts/abi/bind/bind_test.go
+++ b/accounts/abi/bind/bind_test.go
--- a/accounts/abi/bind/template.go
+++ b/accounts/abi/bind/template.go
@ -1,616 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind
-
-import "github.com/ethereum/go-ethereum/accounts/abi"
-
-// tmplData is the data structure required to fill the binding template.
-type tmplData struct {
-	Package   string                   // Name of the package to place the generated file in
-	Contracts map[string]*tmplContract // List of contracts to generate into this file
-	Libraries map[string]string        // Map the bytecode's link pattern to the library name
-}
-
-// tmplContract contains the data needed to generate an individual contract binding.
-type tmplContract struct {
-	Type        string                 // Type name of the main contract binding
-	InputABI    string                 // JSON ABI used as the input to generate the binding from
-	InputBin    string                 // Optional EVM bytecode used to denetare deploy code from
-	FuncSigs    map[string]string      // Optional map: string signature -> 4-byte signature
-	Constructor abi.Method             // Contract constructor for deploy parametrization
-	Calls       map[string]*tmplMethod // Contract calls that only read state data
-	Transacts   map[string]*tmplMethod // Contract calls that write state data
-	Events      map[string]*tmplEvent  // Contract events accessors
-	Libraries   map[string]string      // Same as tmplData, but filtered to only keep what the contract needs
-	Structs     map[string]*tmplStruct // Contract struct type definitions
-	Library     bool
-}
-
-// tmplMethod is a wrapper around an abi.Method that contains a few preprocessed
-// and cached data fields.
-type tmplMethod struct {
-	Original   abi.Method // Original method as parsed by the abi package
-	Normalized abi.Method // Normalized version of the parsed method (capitalized names, non-anonymous args/returns)
-	Structured bool       // Whether the returns should be accumulated into a struct
-}
-
-// tmplEvent is a wrapper around an a
-type tmplEvent struct {
-	Original   abi.Event // Original event as parsed by the abi package
-	Normalized abi.Event // Normalized version of the parsed fields
-}
-
-// tmplField is a wrapper around a struct field with binding language
-// struct type definition and relative filed name.
-type tmplField struct {
-	Type    string   // Field type representation depends on target binding language
-	Name    string   // Field name converted from the raw user-defined field name
-	SolKind abi.Type // Raw abi type information
-}
-
-// tmplStruct is a wrapper around an abi.tuple contains a auto-generated
-// struct name.
-type tmplStruct struct {
-	Name   string       // Auto-generated struct name(We can't obtain the raw struct name through abi)
-	Fields []*tmplField // Struct fields definition depends on the binding language.
-}
-
-// tmplSource is language to template mapping containing all the supported
-// programming languages the package can generate to.
-var tmplSource = map[Lang]string{
-	LangGo:   tmplSourceGo,
-	LangJava: tmplSourceJava,
-}
-
-// tmplSourceGo is the Go source template use to generate the contract binding
-// based on.
-const tmplSourceGo = `
-// Code generated - DO NOT EDIT.
-// This file is a generated binding and any manual changes will be lost.
-
-package {{.Package}}
-
-import (
-	"math/big"
-	"strings"
-
-	ethereum "github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var (
-	_ = big.NewInt
-	_ = strings.NewReader
-	_ = ethereum.NotFound
-	_ = abi.U256
-	_ = bind.Bind
-	_ = common.Big1
-	_ = types.BloomLookup
-	_ = event.NewSubscription
-)
-
-{{range $contract := .Contracts}}
-	{{$structs := $contract.Structs}}
-	// {{.Type}}ABI is the input ABI used to generate the binding from.
-	const {{.Type}}ABI = "{{.InputABI}}"
-
-	{{if $contract.FuncSigs}}
-		// {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
-		var {{.Type}}FuncSigs = map[string]string{
-			{{range $strsig, $binsig := .FuncSigs}}"{{$binsig}}": "{{$strsig}}",
-			{{end}}
-		}
-	{{end}}
-
-	{{if .InputBin}}
-		// {{.Type}}Bin is the compiled bytecode used for deploying new contracts.
-		var {{.Type}}Bin = "0x{{.InputBin}}"
-
-		// Deploy{{.Type}} deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
-		func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type $structs}}{{end}}) (common.Address, *types.Transaction, *{{.Type}}, error) {
-		  parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI))
-		  if err != nil {
-		    return common.Address{}, nil, nil, err
-		  }
-		  {{range $pattern, $name := .Libraries}}
-			{{decapitalise $name}}Addr, _, _, _ := Deploy{{capitalise $name}}(auth, backend)
-			{{$contract.Type}}Bin = strings.Replace({{$contract.Type}}Bin, "__${{$pattern}}$__", {{decapitalise $name}}Addr.String()[2:], -1)
-		  {{end}}
-		  address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex({{.Type}}Bin), backend {{range .Constructor.Inputs}}, {{.Name}}{{end}})
-		  if err != nil {
-		    return common.Address{}, nil, nil, err
-		  }
-		  return address, tx, &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
-		}
-	{{end}}
-
-	// {{.Type}} is an auto generated Go binding around an Ethereum contract.
-	type {{.Type}} struct {
-	  {{.Type}}Caller     // Read-only binding to the contract
-	  {{.Type}}Transactor // Write-only binding to the contract
-	  {{.Type}}Filterer   // Log filterer for contract events
-	}
-
-	// {{.Type}}Caller is an auto generated read-only Go binding around an Ethereum contract.
-	type {{.Type}}Caller struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Transactor is an auto generated write-only Go binding around an Ethereum contract.
-	type {{.Type}}Transactor struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
-	type {{.Type}}Filterer struct {
-	  contract *bind.BoundContract // Generic contract wrapper for the low level calls
-	}
-
-	// {{.Type}}Session is an auto generated Go binding around an Ethereum contract,
-	// with pre-set call and transact options.
-	type {{.Type}}Session struct {
-	  Contract     *{{.Type}}        // Generic contract binding to set the session for
-	  CallOpts     bind.CallOpts     // Call options to use throughout this session
-	  TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
-	}
-
-	// {{.Type}}CallerSession is an auto generated read-only Go binding around an Ethereum contract,
-	// with pre-set call options.
-	type {{.Type}}CallerSession struct {
-	  Contract *{{.Type}}Caller // Generic contract caller binding to set the session for
-	  CallOpts bind.CallOpts    // Call options to use throughout this session
-	}
-
-	// {{.Type}}TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
-	// with pre-set transact options.
-	type {{.Type}}TransactorSession struct {
-	  Contract     *{{.Type}}Transactor // Generic contract transactor binding to set the session for
-	  TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
-	}
-
-	// {{.Type}}Raw is an auto generated low-level Go binding around an Ethereum contract.
-	type {{.Type}}Raw struct {
-	  Contract *{{.Type}} // Generic contract binding to access the raw methods on
-	}
-
-	// {{.Type}}CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
-	type {{.Type}}CallerRaw struct {
-		Contract *{{.Type}}Caller // Generic read-only contract binding to access the raw methods on
-	}
-
-	// {{.Type}}TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
-	type {{.Type}}TransactorRaw struct {
-		Contract *{{.Type}}Transactor // Generic write-only contract binding to access the raw methods on
-	}
-
-	// New{{.Type}} creates a new instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}(address common.Address, backend bind.ContractBackend) (*{{.Type}}, error) {
-	  contract, err := bind{{.Type}}(address, backend, backend, backend)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}{ {{.Type}}Caller: {{.Type}}Caller{contract: contract}, {{.Type}}Transactor: {{.Type}}Transactor{contract: contract}, {{.Type}}Filterer: {{.Type}}Filterer{contract: contract} }, nil
-	}
-
-	// New{{.Type}}Caller creates a new read-only instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}Caller(address common.Address, caller bind.ContractCaller) (*{{.Type}}Caller, error) {
-	  contract, err := bind{{.Type}}(address, caller, nil, nil)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}Caller{contract: contract}, nil
-	}
-
-	// New{{.Type}}Transactor creates a new write-only instance of {{.Type}}, bound to a specific deployed contract.
-	func New{{.Type}}Transactor(address common.Address, transactor bind.ContractTransactor) (*{{.Type}}Transactor, error) {
-	  contract, err := bind{{.Type}}(address, nil, transactor, nil)
-	  if err != nil {
-	    return nil, err
-	  }
-	  return &{{.Type}}Transactor{contract: contract}, nil
-	}
-
-	// New{{.Type}}Filterer creates a new log filterer instance of {{.Type}}, bound to a specific deployed contract.
- 	func New{{.Type}}Filterer(address common.Address, filterer bind.ContractFilterer) (*{{.Type}}Filterer, error) {
- 	  contract, err := bind{{.Type}}(address, nil, nil, filterer)
- 	  if err != nil {
- 	    return nil, err
- 	  }
- 	  return &{{.Type}}Filterer{contract: contract}, nil
- 	}
-
-	// bind{{.Type}} binds a generic wrapper to an already deployed contract.
-	func bind{{.Type}}(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
-	  parsed, err := abi.JSON(strings.NewReader({{.Type}}ABI))
-	  if err != nil {
-	    return nil, err
-	  }
-	  return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
-	}
-
-	// Call invokes the (constant) contract method with params as input values and
-	// sets the output to result. The result type might be a single field for simple
-	// returns, a slice of interfaces for anonymous returns and a struct for named
-	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Caller.contract.Call(opts, result, method, params...)
-	}
-
-	// Transfer initiates a plain transaction to move funds to the contract, calling
-	// its default method if one is available.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transfer(opts)
-	}
-
-	// Transact invokes the (paid) contract method with params as input values.
-	func (_{{$contract.Type}} *{{$contract.Type}}Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.{{$contract.Type}}Transactor.contract.Transact(opts, method, params...)
-	}
-
-	// Call invokes the (constant) contract method with params as input values and
-	// sets the output to result. The result type might be a single field for simple
-	// returns, a slice of interfaces for anonymous returns and a struct for named
-	// returns.
-	func (_{{$contract.Type}} *{{$contract.Type}}CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
-		return _{{$contract.Type}}.Contract.contract.Call(opts, result, method, params...)
-	}
-
-	// Transfer initiates a plain transaction to move funds to the contract, calling
-	// its default method if one is available.
-	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.contract.Transfer(opts)
-	}
-
-	// Transact invokes the (paid) contract method with params as input values.
-	func (_{{$contract.Type}} *{{$contract.Type}}TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
-		return _{{$contract.Type}}.Contract.contract.Transact(opts, method, params...)
-	}
-
-	{{range .Structs}}
-		// {{.Name}} is an auto generated low-level Go binding around an user-defined struct.
-		type {{.Name}} struct {
-		{{range $field := .Fields}}
-		{{$field.Name}} {{$field.Type}}{{end}}
-		}
-	{{end}}
-
-	{{range .Calls}}
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}}{{end}} error) {
-			{{if .Structured}}ret := new(struct{
-				{{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}}
-				{{end}}
-			}){{else}}var (
-				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}} = new({{bindtype .Type $structs}})
-				{{end}}
-			){{end}}
-			out := {{if .Structured}}ret{{else}}{{if eq (len .Normalized.Outputs) 1}}ret0{{else}}&[]interface{}{
-				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}},
-				{{end}}
-			}{{end}}{{end}}
-			err := _{{$contract.Type}}.contract.Call(opts, out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-			return {{if .Structured}}*ret,{{else}}{{range $i, $_ := .Normalized.Outputs}}*ret{{$i}},{{end}}{{end}} err
-		}
-
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}CallerSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type $structs}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type $structs}},{{end}} {{end}} error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.CallOpts {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-	{{end}}
-
-	{{range .Transacts}}
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.Transact(opts, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-
-		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatmethod .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
-		}
-	{{end}}
-
-	{{range .Events}}
-		// {{$contract.Type}}{{.Normalized.Name}}Iterator is returned from Filter{{.Normalized.Name}} and is used to iterate over the raw logs and unpacked data for {{.Normalized.Name}} events raised by the {{$contract.Type}} contract.
-		type {{$contract.Type}}{{.Normalized.Name}}Iterator struct {
-			Event *{{$contract.Type}}{{.Normalized.Name}} // Event containing the contract specifics and raw log
-
-			contract *bind.BoundContract // Generic contract to use for unpacking event data
-			event    string              // Event name to use for unpacking event data
-
-			logs chan types.Log        // Log channel receiving the found contract events
-			sub  ethereum.Subscription // Subscription for errors, completion and termination
-			done bool                  // Whether the subscription completed delivering logs
-			fail error                 // Occurred error to stop iteration
-		}
-		// Next advances the iterator to the subsequent event, returning whether there
-		// are any more events found. In case of a retrieval or parsing error, false is
-		// returned and Error() can be queried for the exact failure.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Next() bool {
-			// If the iterator failed, stop iterating
-			if (it.fail != nil) {
-				return false
-			}
-			// If the iterator completed, deliver directly whatever's available
-			if (it.done) {
-				select {
-				case log := <-it.logs:
-					it.Event = new({{$contract.Type}}{{.Normalized.Name}})
-					if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-						it.fail = err
-						return false
-					}
-					it.Event.Raw = log
-					return true
-
-				default:
-					return false
-				}
-			}
-			// Iterator still in progress, wait for either a data or an error event
-			select {
-			case log := <-it.logs:
-				it.Event = new({{$contract.Type}}{{.Normalized.Name}})
-				if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
-					it.fail = err
-					return false
-				}
-				it.Event.Raw = log
-				return true
-
-			case err := <-it.sub.Err():
-				it.done = true
-				it.fail = err
-				return it.Next()
-			}
-		}
-		// Error returns any retrieval or parsing error occurred during filtering.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Error() error {
-			return it.fail
-		}
-		// Close terminates the iteration process, releasing any pending underlying
-		// resources.
-		func (it *{{$contract.Type}}{{.Normalized.Name}}Iterator) Close() error {
-			it.sub.Unsubscribe()
-			return nil
-		}
-
-		// {{$contract.Type}}{{.Normalized.Name}} represents a {{.Normalized.Name}} event raised by the {{$contract.Type}} contract.
-		type {{$contract.Type}}{{.Normalized.Name}} struct { {{range .Normalized.Inputs}}
-			{{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type $structs}}{{else}}{{bindtype .Type $structs}}{{end}}; {{end}}
-			Raw types.Log // Blockchain specific contextual infos
-		}
-
-		// Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatevent .Original $structs}}
- 		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) {
-			{{range .Normalized.Inputs}}
-			{{if .Indexed}}var {{.Name}}Rule []interface{}
-			for _, {{.Name}}Item := range {{.Name}} {
-				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
-			}{{end}}{{end}}
-
-			logs, sub, err := _{{$contract.Type}}.contract.FilterLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
-			if err != nil {
-				return nil, err
-			}
-			return &{{$contract.Type}}{{.Normalized.Name}}Iterator{contract: _{{$contract.Type}}.contract, event: "{{.Original.Name}}", logs: logs, sub: sub}, nil
- 		}
-
-		// Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{formatevent .Original $structs}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Watch{{.Normalized.Name}}(opts *bind.WatchOpts, sink chan<- *{{$contract.Type}}{{.Normalized.Name}}{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type $structs}}{{end}}{{end}}) (event.Subscription, error) {
-			{{range .Normalized.Inputs}}
-			{{if .Indexed}}var {{.Name}}Rule []interface{}
-			for _, {{.Name}}Item := range {{.Name}} {
-				{{.Name}}Rule = append({{.Name}}Rule, {{.Name}}Item)
-			}{{end}}{{end}}
-
-			logs, sub, err := _{{$contract.Type}}.contract.WatchLogs(opts, "{{.Original.Name}}"{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}}Rule{{end}}{{end}})
-			if err != nil {
-				return nil, err
-			}
-			return event.NewSubscription(func(quit <-chan struct{}) error {
-				defer sub.Unsubscribe()
-				for {
-					select {
-					case log := <-logs:
-						// New log arrived, parse the event and forward to the user
-						event := new({{$contract.Type}}{{.Normalized.Name}})
-						if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
-							return err
-						}
-						event.Raw = log
-
-						select {
-						case sink <- event:
-						case err := <-sub.Err():
-							return err
-						case <-quit:
-							return nil
-						}
-					case err := <-sub.Err():
-						return err
-					case <-quit:
-						return nil
-					}
-				}
-			}), nil
-		}
-
-		// Parse{{.Normalized.Name}} is a log parse operation binding the contract event 0x{{printf "%x" .Original.ID}}.
-		//
-		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Parse{{.Normalized.Name}}(log types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
-			event := new({{$contract.Type}}{{.Normalized.Name}})
-			if err := _{{$contract.Type}}.contract.UnpackLog(event, "{{.Original.Name}}", log); err != nil {
-				return nil, err
-			}
-			return event, nil
-		}
-
- 	{{end}}
-{{end}}
-`
-
-// tmplSourceJava is the Java source template use to generate the contract binding
-// based on.
-const tmplSourceJava = `
-// This file is an automatically generated Java binding. Do not modify as any
-// change will likely be lost upon the next re-generation!
-
-package {{.Package}};
-
-import org.ethereum.geth.*;
-import java.util.*;
-
-{{range $contract := .Contracts}}
-{{$structs := $contract.Structs}}
-{{if not .Library}}public {{end}}class {{.Type}} {
-	// ABI is the input ABI used to generate the binding from.
-	public final static String ABI = "{{.InputABI}}";
-	{{if $contract.FuncSigs}}
-		// {{.Type}}FuncSigs maps the 4-byte function signature to its string representation.
-		public final static Map<String, String> {{.Type}}FuncSigs;
-		static {
-			Hashtable<String, String> temp = new Hashtable<String, String>();
-			{{range $strsig, $binsig := .FuncSigs}}temp.put("{{$binsig}}", "{{$strsig}}");
-			{{end}}
-			{{.Type}}FuncSigs = Collections.unmodifiableMap(temp);
-		}
-	{{end}}
-	{{if .InputBin}}
-	// BYTECODE is the compiled bytecode used for deploying new contracts.
-	public final static String BYTECODE = "0x{{.InputBin}}";
-
-	// deploy deploys a new Ethereum contract, binding an instance of {{.Type}} to it.
-	public static {{.Type}} deploy(TransactOpts auth, EthereumClient client{{range .Constructor.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
-		Interfaces args = Geth.newInterfaces({{(len .Constructor.Inputs)}});
-		String bytecode = BYTECODE;
-		{{if .Libraries}}
-
-		// "link" contract to dependent libraries by deploying them first.
-		{{range $pattern, $name := .Libraries}}
-		{{capitalise $name}} {{decapitalise $name}}Inst = {{capitalise $name}}.deploy(auth, client);
-		bytecode = bytecode.replace("__${{$pattern}}$__", {{decapitalise $name}}Inst.Address.getHex().substring(2));
-		{{end}}
-		{{end}}
-		{{range $index, $element := .Constructor.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
-		{{end}}
-		return new {{.Type}}(Geth.deployContract(auth, ABI, Geth.decodeFromHex(bytecode), client, args));
-	}
-
-	// Internal constructor used by contract deployment.
-	private {{.Type}}(BoundContract deployment) {
-		this.Address  = deployment.getAddress();
-		this.Deployer = deployment.getDeployer();
-		this.Contract = deployment;
-	}
-	{{end}}
-
-	// Ethereum address where this contract is located at.
-	public final Address Address;
-
-	// Ethereum transaction in which this contract was deployed (if known!).
-	public final Transaction Deployer;
-
-	// Contract instance bound to a blockchain address.
-	private final BoundContract Contract;
-
-	// Creates a new instance of {{.Type}}, bound to a specific deployed contract.
-	public {{.Type}}(Address address, EthereumClient client) throws Exception {
-		this(Geth.bindContract(address, ABI, client));
-	}
-
-	{{range .Calls}}
-	{{if gt (len .Normalized.Outputs) 1}}
-	// {{capitalise .Normalized.Name}}Results is the output of a call to {{.Normalized.Name}}.
-	public class {{capitalise .Normalized.Name}}Results {
-		{{range $index, $item := .Normalized.Outputs}}public {{bindtype .Type $structs}} {{if ne .Name ""}}{{.Name}}{{else}}Return{{$index}}{{end}};
-		{{end}}
-	}
-	{{end}}
-
-	// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
-	//
-	// Solidity: {{.Original.String}}
-	public {{if gt (len .Normalized.Outputs) 1}}{{capitalise .Normalized.Name}}Results{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}}{{end}}{{end}} {{.Normalized.Name}}(CallOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
-		Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
-		{{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
-		{{end}}
-
-		Interfaces results = Geth.newInterfaces({{(len .Normalized.Outputs)}});
-		{{range $index, $item := .Normalized.Outputs}}Interface result{{$index}} = Geth.newInterface(); result{{$index}}.setDefault{{namedtype (bindtype .Type $structs) .Type}}(); results.set({{$index}}, result{{$index}});
-		{{end}}
-
-		if (opts == null) {
-			opts = Geth.newCallOpts();
-		}
-		this.Contract.call(opts, results, "{{.Original.Name}}", args);
-		{{if gt (len .Normalized.Outputs) 1}}
-			{{capitalise .Normalized.Name}}Results result = new {{capitalise .Normalized.Name}}Results();
-			{{range $index, $item := .Normalized.Outputs}}result.{{if ne .Name ""}}{{.Name}}{{else}}Return{{$index}}{{end}} = results.get({{$index}}).get{{namedtype (bindtype .Type $structs) .Type}}();
-			{{end}}
-			return result;
-		{{else}}{{range .Normalized.Outputs}}return results.get(0).get{{namedtype (bindtype .Type $structs) .Type}}();{{end}}
-		{{end}}
-	}
-	{{end}}
-
-	{{range .Transacts}}
-	// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
-	//
-	// Solidity: {{.Original.String}}
-	public Transaction {{.Normalized.Name}}(TransactOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
-		Interfaces args = Geth.newInterfaces({{(len .Normalized.Inputs)}});
-		{{range $index, $item := .Normalized.Inputs}}Interface arg{{$index}} = Geth.newInterface();arg{{$index}}.set{{namedtype (bindtype .Type $structs) .Type}}({{.Name}});args.set({{$index}},arg{{$index}});
-		{{end}}
-		return this.Contract.transact(opts, "{{.Original.Name}}"	, args);
-	}
-	{{end}}
-}
-{{end}}
-`
--- a/accounts/abi/bind/topics_test.go
+++ b/accounts/abi/bind/topics_test.go
@ -1,103 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestMakeTopics(t *testing.T) {
-	type args struct {
-		query [][]interface{}
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    [][]common.Hash
-		wantErr bool
-	}{
-		{
-			"support fixed byte types, right padded to 32 bytes",
-			args{[][]interface{}{{[5]byte{1, 2, 3, 4, 5}}}},
-			[][]common.Hash{{common.Hash{1, 2, 3, 4, 5}}},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := makeTopics(tt.args.query...)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("makeTopics() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("makeTopics() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestParseTopics(t *testing.T) {
-	type bytesStruct struct {
-		StaticBytes [5]byte
-	}
-	bytesType, _ := abi.NewType("bytes5", nil)
-	type args struct {
-		createObj func() interface{}
-		resultObj func() interface{}
-		fields    abi.Arguments
-		topics    []common.Hash
-	}
-	tests := []struct {
-		name    string
-		args    args
-		wantErr bool
-	}{
-		{
-			name: "support fixed byte types, right padded to 32 bytes",
-			args: args{
-				createObj: func() interface{} { return &bytesStruct{} },
-				resultObj: func() interface{} { return &bytesStruct{StaticBytes: [5]byte{1, 2, 3, 4, 5}} },
-				fields: abi.Arguments{abi.Argument{
-					Name:    "staticBytes",
-					Type:    bytesType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{1, 2, 3, 4, 5},
-				},
-			},
-			wantErr: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			createObj := tt.args.createObj()
-			if err := parseTopics(createObj, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
-				t.Errorf("parseTopics() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			resultObj := tt.args.resultObj()
-			if !reflect.DeepEqual(createObj, resultObj) {
-				t.Errorf("parseTopics() = %v, want %v", createObj, resultObj)
-			}
-		})
-	}
-}
--- a/accounts/abi/bind/util_test.go
+++ b/accounts/abi/bind/util_test.go
@ -1,96 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package bind_test
-
-import (
-	"context"
-	"math/big"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
-
-var waitDeployedTests = map[string]struct {
-	code        string
-	gas         uint64
-	wantAddress common.Address
-	wantErr     error
-}{
-	"successful deploy": {
-		code:        `6060604052600a8060106000396000f360606040526008565b00`,
-		gas:         3000000,
-		wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
-	},
-	"empty code": {
-		code:        ``,
-		gas:         300000,
-		wantErr:     bind.ErrNoCodeAfterDeploy,
-		wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"),
-	},
-}
-
-func TestWaitDeployed(t *testing.T) {
-	for name, test := range waitDeployedTests {
-		backend := backends.NewSimulatedBackend(
-			core.GenesisAlloc{
-				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000)},
-			},
-			10000000,
-		)
-		defer backend.Close()
-
-		// Create the transaction.
-		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, big.NewInt(1), common.FromHex(test.code))
-		tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
-
-		// Wait for it to get mined in the background.
-		var (
-			err     error
-			address common.Address
-			mined   = make(chan struct{})
-			ctx     = context.Background()
-		)
-		go func() {
-			address, err = bind.WaitDeployed(ctx, backend, tx)
-			close(mined)
-		}()
-
-		// Send and mine the transaction.
-		backend.SendTransaction(ctx, tx)
-		backend.Commit()
-
-		select {
-		case <-mined:
-			if err != test.wantErr {
-				t.Errorf("test %q: error mismatch: got %q, want %q", name, err, test.wantErr)
-			}
-			if address != test.wantAddress {
-				t.Errorf("test %q: unexpected contract address %s", name, address.Hex())
-			}
-		case <-time.After(2 * time.Second):
-			t.Errorf("test %q: timeout", name)
-		}
-	}
-}
--- a/accounts/abi/event.go
+++ b/accounts/abi/event.go
@ -1,77 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// Event is an event potentially triggered by the EVM's LOG mechanism. The Event
-// holds type information (inputs) about the yielded output. Anonymous events
-// don't get the signature canonical representation as the first LOG topic.
-type Event struct {
-	// Name is the event name used for internal representation. It's derived from
-	// the raw name and a suffix will be added in the case of a event overload.
-	//
-	// e.g.
-	// There are two events have same name:
-	// * foo(int,int)
-	// * foo(uint,uint)
-	// The event name of the first one wll be resolved as foo while the second one
-	// will be resolved as foo0.
-	Name string
-	// RawName is the raw event name parsed from ABI.
-	RawName   string
-	Anonymous bool
-	Inputs    Arguments
-}
-
-func (e Event) String() string {
-	inputs := make([]string, len(e.Inputs))
-	for i, input := range e.Inputs {
-		inputs[i] = fmt.Sprintf("%v %v", input.Type, input.Name)
-		if input.Indexed {
-			inputs[i] = fmt.Sprintf("%v indexed %v", input.Type, input.Name)
-		}
-	}
-	return fmt.Sprintf("event %v(%v)", e.RawName, strings.Join(inputs, ", "))
-}
-
-// Sig returns the event string signature according to the ABI spec.
-//
-// Example
-//
-//     event foo(uint32 a, int b) = "foo(uint32,int256)"
-//
-// Please note that "int" is substitute for its canonical representation "int256"
-func (e Event) Sig() string {
-	types := make([]string, len(e.Inputs))
-	for i, input := range e.Inputs {
-		types[i] = input.Type.String()
-	}
-	return fmt.Sprintf("%v(%v)", e.RawName, strings.Join(types, ","))
-}
-
-// ID returns the canonical representation of the event's signature used by the
-// abi definition to identify event names and types.
-func (e Event) ID() common.Hash {
-	return common.BytesToHash(crypto.Keccak256([]byte(e.Sig())))
-}
--- a/accounts/abi/event_test.go
+++ b/accounts/abi/event_test.go
@ -1,428 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"bytes"
-	"encoding/hex"
-	"encoding/json"
-	"math/big"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-var jsonEventTransfer = []byte(`{
-  "anonymous": false,
-  "inputs": [
-    {
-      "indexed": true, "name": "from", "type": "address"
-    }, {
-      "indexed": true, "name": "to", "type": "address"
-    }, {
-      "indexed": false, "name": "value", "type": "uint256"
-  }],
-  "name": "Transfer",
-  "type": "event"
-}`)
-
-var jsonEventPledge = []byte(`{
-  "anonymous": false,
-  "inputs": [{
-      "indexed": false, "name": "who", "type": "address"
-    }, {
-      "indexed": false, "name": "wad", "type": "uint128"
-    }, {
-      "indexed": false, "name": "currency", "type": "bytes3"
-  }],
-  "name": "Pledge",
-  "type": "event"
-}`)
-
-var jsonEventMixedCase = []byte(`{
-	"anonymous": false,
-	"inputs": [{
-		"indexed": false, "name": "value", "type": "uint256"
-	  }, {
-		"indexed": false, "name": "_value", "type": "uint256"
-	  }, {
-		"indexed": false, "name": "Value", "type": "uint256"
-	}],
-	"name": "MixedCase",
-	"type": "event"
-  }`)
-
-// 1000000
-var transferData1 = "00000000000000000000000000000000000000000000000000000000000f4240"
-
-// "0x00Ce0d46d924CC8437c806721496599FC3FFA268", 2218516807680, "usd"
-var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa2680000000000000000000000000000000000000000000000000000020489e800007573640000000000000000000000000000000000000000000000000000000000"
-
-// 1000000,2218516807680,1000001
-var mixedCaseData1 = "00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000000020489e8000000000000000000000000000000000000000000000000000000000000000f4241"
-
-func TestEventId(t *testing.T) {
-	var table = []struct {
-		definition   string
-		expectations map[string]common.Hash
-	}{
-		{
-			definition: `[
-			{ "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
-			{ "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] }
-			]`,
-			expectations: map[string]common.Hash{
-				"Balance": crypto.Keccak256Hash([]byte("Balance(uint256)")),
-				"Check":   crypto.Keccak256Hash([]byte("Check(address,uint256)")),
-			},
-		},
-	}
-
-	for _, test := range table {
-		abi, err := JSON(strings.NewReader(test.definition))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for name, event := range abi.Events {
-			if event.ID() != test.expectations[name] {
-				t.Errorf("expected id to be %x, got %x", test.expectations[name], event.ID())
-			}
-		}
-	}
-}
-
-func TestEventString(t *testing.T) {
-	var table = []struct {
-		definition   string
-		expectations map[string]string
-	}{
-		{
-			definition: `[
-			{ "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
-			{ "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] },
-			{ "type" : "event", "name" : "Transfer", "inputs": [{ "name": "from", "type": "address", "indexed": true }, { "name": "to", "type": "address", "indexed": true }, { "name": "value", "type": "uint256" }] }
-			]`,
-			expectations: map[string]string{
-				"Balance":  "event Balance(uint256 in)",
-				"Check":    "event Check(address t, uint256 b)",
-				"Transfer": "event Transfer(address indexed from, address indexed to, uint256 value)",
-			},
-		},
-	}
-
-	for _, test := range table {
-		abi, err := JSON(strings.NewReader(test.definition))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		for name, event := range abi.Events {
-			if event.String() != test.expectations[name] {
-				t.Errorf("expected string to be %s, got %s", test.expectations[name], event.String())
-			}
-		}
-	}
-}
-
-// TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array.
-func TestEventMultiValueWithArrayUnpack(t *testing.T) {
-	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
-	type testStruct struct {
-		Value1 [2]uint8
-		Value2 uint8
-	}
-	abi, err := JSON(strings.NewReader(definition))
-	require.NoError(t, err)
-	var b bytes.Buffer
-	var i uint8 = 1
-	for ; i <= 3; i++ {
-		b.Write(packNum(reflect.ValueOf(i)))
-	}
-	var rst testStruct
-	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
-	require.Equal(t, [2]uint8{1, 2}, rst.Value1)
-	require.Equal(t, uint8(3), rst.Value2)
-}
-
-func TestEventTupleUnpack(t *testing.T) {
-
-	type EventTransfer struct {
-		Value *big.Int
-	}
-
-	type EventTransferWithTag struct {
-		// this is valid because `value` is not exportable,
-		// so value is only unmarshalled into `Value1`.
-		value  *big.Int
-		Value1 *big.Int `abi:"value"`
-	}
-
-	type BadEventTransferWithSameFieldAndTag struct {
-		Value  *big.Int
-		Value1 *big.Int `abi:"value"`
-	}
-
-	type BadEventTransferWithDuplicatedTag struct {
-		Value1 *big.Int `abi:"value"`
-		Value2 *big.Int `abi:"value"`
-	}
-
-	type BadEventTransferWithEmptyTag struct {
-		Value *big.Int `abi:""`
-	}
-
-	type EventPledge struct {
-		Who      common.Address
-		Wad      *big.Int
-		Currency [3]byte
-	}
-
-	type BadEventPledge struct {
-		Who      string
-		Wad      int
-		Currency [3]byte
-	}
-
-	type EventMixedCase struct {
-		Value1 *big.Int `abi:"value"`
-		Value2 *big.Int `abi:"_value"`
-		Value3 *big.Int `abi:"Value"`
-	}
-
-	bigint := new(big.Int)
-	bigintExpected := big.NewInt(1000000)
-	bigintExpected2 := big.NewInt(2218516807680)
-	bigintExpected3 := big.NewInt(1000001)
-	addr := common.HexToAddress("0x00Ce0d46d924CC8437c806721496599FC3FFA268")
-	var testCases = []struct {
-		data     string
-		dest     interface{}
-		expected interface{}
-		jsonLog  []byte
-		error    string
-		name     string
-	}{{
-		transferData1,
-		&EventTransfer{},
-		&EventTransfer{Value: bigintExpected},
-		jsonEventTransfer,
-		"",
-		"Can unpack ERC20 Transfer event into structure",
-	}, {
-		transferData1,
-		&[]interface{}{&bigint},
-		&[]interface{}{&bigintExpected},
-		jsonEventTransfer,
-		"",
-		"Can unpack ERC20 Transfer event into slice",
-	}, {
-		transferData1,
-		&EventTransferWithTag{},
-		&EventTransferWithTag{Value1: bigintExpected},
-		jsonEventTransfer,
-		"",
-		"Can unpack ERC20 Transfer event into structure with abi: tag",
-	}, {
-		transferData1,
-		&BadEventTransferWithDuplicatedTag{},
-		&BadEventTransferWithDuplicatedTag{},
-		jsonEventTransfer,
-		"struct: abi tag in 'Value2' already mapped",
-		"Can not unpack ERC20 Transfer event with duplicated abi tag",
-	}, {
-		transferData1,
-		&BadEventTransferWithSameFieldAndTag{},
-		&BadEventTransferWithSameFieldAndTag{},
-		jsonEventTransfer,
-		"abi: multiple variables maps to the same abi field 'value'",
-		"Can not unpack ERC20 Transfer event with a field and a tag mapping to the same abi variable",
-	}, {
-		transferData1,
-		&BadEventTransferWithEmptyTag{},
-		&BadEventTransferWithEmptyTag{},
-		jsonEventTransfer,
-		"struct: abi tag in 'Value' is empty",
-		"Can not unpack ERC20 Transfer event with an empty tag",
-	}, {
-		pledgeData1,
-		&EventPledge{},
-		&EventPledge{
-			addr,
-			bigintExpected2,
-			[3]byte{'u', 's', 'd'}},
-		jsonEventPledge,
-		"",
-		"Can unpack Pledge event into structure",
-	}, {
-		pledgeData1,
-		&[]interface{}{&common.Address{}, &bigint, &[3]byte{}},
-		&[]interface{}{
-			&addr,
-			&bigintExpected2,
-			&[3]byte{'u', 's', 'd'}},
-		jsonEventPledge,
-		"",
-		"Can unpack Pledge event into slice",
-	}, {
-		pledgeData1,
-		&[3]interface{}{&common.Address{}, &bigint, &[3]byte{}},
-		&[3]interface{}{
-			&addr,
-			&bigintExpected2,
-			&[3]byte{'u', 's', 'd'}},
-		jsonEventPledge,
-		"",
-		"Can unpack Pledge event into an array",
-	}, {
-		pledgeData1,
-		&[]interface{}{new(int), 0, 0},
-		&[]interface{}{},
-		jsonEventPledge,
-		"abi: cannot unmarshal common.Address in to int",
-		"Can not unpack Pledge event into slice with wrong types",
-	}, {
-		pledgeData1,
-		&BadEventPledge{},
-		&BadEventPledge{},
-		jsonEventPledge,
-		"abi: cannot unmarshal common.Address in to string",
-		"Can not unpack Pledge event into struct with wrong filed types",
-	}, {
-		pledgeData1,
-		&[]interface{}{common.Address{}, new(big.Int)},
-		&[]interface{}{},
-		jsonEventPledge,
-		"abi: insufficient number of elements in the list/array for unpack, want 3, got 2",
-		"Can not unpack Pledge event into too short slice",
-	}, {
-		pledgeData1,
-		new(map[string]interface{}),
-		&[]interface{}{},
-		jsonEventPledge,
-		"abi: cannot unmarshal tuple into map[string]interface {}",
-		"Can not unpack Pledge event into map",
-	}, {
-		mixedCaseData1,
-		&EventMixedCase{},
-		&EventMixedCase{Value1: bigintExpected, Value2: bigintExpected2, Value3: bigintExpected3},
-		jsonEventMixedCase,
-		"",
-		"Can unpack abi variables with mixed case",
-	}}
-
-	for _, tc := range testCases {
-		assert := assert.New(t)
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert)
-			if tc.error == "" {
-				assert.Nil(err, "Should be able to unpack event data.")
-				assert.Equal(tc.expected, tc.dest, tc.name)
-			} else {
-				assert.EqualError(err, tc.error, tc.name)
-			}
-		})
-	}
-}
-
-func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, assert *assert.Assertions) error {
-	data, err := hex.DecodeString(hexData)
-	assert.NoError(err, "Hex data should be a correct hex-string")
-	var e Event
-	assert.NoError(json.Unmarshal(jsonEvent, &e), "Should be able to unmarshal event ABI")
-	a := ABI{Events: map[string]Event{"e": e}}
-	return a.Unpack(dest, "e", data)
-}
-
-/*
-Taken from
-https://github.com/ethereum/go-ethereum/pull/15568
-*/
-
-type testResult struct {
-	Values [2]*big.Int
-	Value1 *big.Int
-	Value2 *big.Int
-}
-
-type testCase struct {
-	definition string
-	want       testResult
-}
-
-func (tc testCase) encoded(intType, arrayType Type) []byte {
-	var b bytes.Buffer
-	if tc.want.Value1 != nil {
-		val, _ := intType.pack(reflect.ValueOf(tc.want.Value1))
-		b.Write(val)
-	}
-
-	if !reflect.DeepEqual(tc.want.Values, [2]*big.Int{nil, nil}) {
-		val, _ := arrayType.pack(reflect.ValueOf(tc.want.Values))
-		b.Write(val)
-	}
-	if tc.want.Value2 != nil {
-		val, _ := intType.pack(reflect.ValueOf(tc.want.Value2))
-		b.Write(val)
-	}
-	return b.Bytes()
-}
-
-// TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder.
-func TestEventUnpackIndexed(t *testing.T) {
-	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
-	type testStruct struct {
-		Value1 uint8
-		Value2 uint8
-	}
-	abi, err := JSON(strings.NewReader(definition))
-	require.NoError(t, err)
-	var b bytes.Buffer
-	b.Write(packNum(reflect.ValueOf(uint8(8))))
-	var rst testStruct
-	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
-	require.Equal(t, uint8(0), rst.Value1)
-	require.Equal(t, uint8(8), rst.Value2)
-}
-
-// TestEventIndexedWithArrayUnpack verifies that decoder will not overlow when static array is indexed input.
-func TestEventIndexedWithArrayUnpack(t *testing.T) {
-	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]`
-	type testStruct struct {
-		Value1 [2]uint8
-		Value2 string
-	}
-	abi, err := JSON(strings.NewReader(definition))
-	require.NoError(t, err)
-	var b bytes.Buffer
-	stringOut := "abc"
-	// number of fields that will be encoded * 32
-	b.Write(packNum(reflect.ValueOf(32)))
-	b.Write(packNum(reflect.ValueOf(len(stringOut))))
-	b.Write(common.RightPadBytes([]byte(stringOut), 32))
-
-	var rst testStruct
-	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
-	require.Equal(t, [2]uint8{0, 0}, rst.Value1)
-	require.Equal(t, stringOut, rst.Value2)
-}
--- a/accounts/abi/method.go
+++ b/accounts/abi/method.go
@ -1,90 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// Method represents a callable given a `Name` and whether the method is a constant.
-// If the method is `Const` no transaction needs to be created for this
-// particular Method call. It can easily be simulated using a local VM.
-// For example a `Balance()` method only needs to retrieve something
-// from the storage and therefore requires no Tx to be send to the
-// network. A method such as `Transact` does require a Tx and thus will
-// be flagged `false`.
-// Input specifies the required input parameters for this gives method.
-type Method struct {
-	// Name is the method name used for internal representation. It's derived from
-	// the raw name and a suffix will be added in the case of a function overload.
-	//
-	// e.g.
-	// There are two functions have same name:
-	// * foo(int,int)
-	// * foo(uint,uint)
-	// The method name of the first one will be resolved as foo while the second one
-	// will be resolved as foo0.
-	Name string
-	// RawName is the raw method name parsed from ABI.
-	RawName string
-	Const   bool
-	Inputs  Arguments
-	Outputs Arguments
-}
-
-// Sig returns the methods string signature according to the ABI spec.
-//
-// Example
-//
-//     function foo(uint32 a, int b) = "foo(uint32,int256)"
-//
-// Please note that "int" is substitute for its canonical representation "int256"
-func (method Method) Sig() string {
-	types := make([]string, len(method.Inputs))
-	for i, input := range method.Inputs {
-		types[i] = input.Type.String()
-	}
-	return fmt.Sprintf("%v(%v)", method.RawName, strings.Join(types, ","))
-}
-
-func (method Method) String() string {
-	inputs := make([]string, len(method.Inputs))
-	for i, input := range method.Inputs {
-		inputs[i] = fmt.Sprintf("%v %v", input.Type, input.Name)
-	}
-	outputs := make([]string, len(method.Outputs))
-	for i, output := range method.Outputs {
-		outputs[i] = output.Type.String()
-		if len(output.Name) > 0 {
-			outputs[i] += fmt.Sprintf(" %v", output.Name)
-		}
-	}
-	constant := ""
-	if method.Const {
-		constant = "constant "
-	}
-	return fmt.Sprintf("function %v(%v) %sreturns(%v)", method.RawName, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", "))
-}
-
-// ID returns the canonical representation of the method's signature used by the
-// abi definition to identify method names and types.
-func (method Method) ID() []byte {
-	return crypto.Keccak256([]byte(method.Sig()))[:4]
-}
--- a/accounts/abi/method_test.go
+++ b/accounts/abi/method_test.go
@ -1,128 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"strings"
-	"testing"
-)
-
-const methoddata = `
-[
-	{"type": "function", "name": "balance", "constant": true },
-	{"type": "function", "name": "send", "constant": false, "inputs": [{ "name": "amount", "type": "uint256" }]},
-	{"type": "function", "name": "transfer", "constant": false, "inputs": [{"name": "from", "type": "address"}, {"name": "to", "type": "address"}, {"name": "value", "type": "uint256"}], "outputs": [{"name": "success", "type": "bool"}]},
-	{"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple"}],"name":"tuple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
-	{"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[]"}],"name":"tupleSlice","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
-	{"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[5]"}],"name":"tupleArray","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},
-	{"constant":false,"inputs":[{"components":[{"name":"x","type":"uint256"},{"name":"y","type":"uint256"}],"name":"a","type":"tuple[5][]"}],"name":"complexTuple","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}
-]`
-
-func TestMethodString(t *testing.T) {
-	var table = []struct {
-		method      string
-		expectation string
-	}{
-		{
-			method:      "balance",
-			expectation: "function balance() constant returns()",
-		},
-		{
-			method:      "send",
-			expectation: "function send(uint256 amount) returns()",
-		},
-		{
-			method:      "transfer",
-			expectation: "function transfer(address from, address to, uint256 value) returns(bool success)",
-		},
-		{
-			method:      "tuple",
-			expectation: "function tuple((uint256,uint256) a) returns()",
-		},
-		{
-			method:      "tupleArray",
-			expectation: "function tupleArray((uint256,uint256)[5] a) returns()",
-		},
-		{
-			method:      "tupleSlice",
-			expectation: "function tupleSlice((uint256,uint256)[] a) returns()",
-		},
-		{
-			method:      "complexTuple",
-			expectation: "function complexTuple((uint256,uint256)[5][] a) returns()",
-		},
-	}
-
-	abi, err := JSON(strings.NewReader(methoddata))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, test := range table {
-		got := abi.Methods[test.method].String()
-		if got != test.expectation {
-			t.Errorf("expected string to be %s, got %s", test.expectation, got)
-		}
-	}
-}
-
-func TestMethodSig(t *testing.T) {
-	var cases = []struct {
-		method string
-		expect string
-	}{
-		{
-			method: "balance",
-			expect: "balance()",
-		},
-		{
-			method: "send",
-			expect: "send(uint256)",
-		},
-		{
-			method: "transfer",
-			expect: "transfer(address,address,uint256)",
-		},
-		{
-			method: "tuple",
-			expect: "tuple((uint256,uint256))",
-		},
-		{
-			method: "tupleArray",
-			expect: "tupleArray((uint256,uint256)[5])",
-		},
-		{
-			method: "tupleSlice",
-			expect: "tupleSlice((uint256,uint256)[])",
-		},
-		{
-			method: "complexTuple",
-			expect: "complexTuple((uint256,uint256)[5][])",
-		},
-	}
-	abi, err := JSON(strings.NewReader(methoddata))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	for _, test := range cases {
-		got := abi.Methods[test.method].Sig()
-		if got != test.expect {
-			t.Errorf("expected string to be %s, got %s", test.expect, got)
-		}
-	}
-}
--- a/accounts/abi/numbers_test.go
+++ b/accounts/abi/numbers_test.go
@ -1,33 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"bytes"
-	"math/big"
-	"testing"
-)
-
-func TestNumberTypes(t *testing.T) {
-	ubytes := make([]byte, 32)
-	ubytes[31] = 1
-
-	unsigned := U256(big.NewInt(1))
-	if !bytes.Equal(unsigned, ubytes) {
-		t.Errorf("expected %x got %x", ubytes, unsigned)
-	}
-}
--- a/accounts/abi/pack_test.go
+++ b/accounts/abi/pack_test.go
@ -1,783 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"bytes"
-	"math"
-	"math/big"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-func TestPack(t *testing.T) {
-	for i, test := range []struct {
-		typ        string
-		components []ArgumentMarshaling
-		input      interface{}
-		output     []byte
-	}{
-		{
-			"uint8",
-			nil,
-			uint8(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint8[]",
-			nil,
-			[]uint8{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint16",
-			nil,
-			uint16(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint16[]",
-			nil,
-			[]uint16{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint32",
-			nil,
-			uint32(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint32[]",
-			nil,
-			[]uint32{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint64",
-			nil,
-			uint64(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint64[]",
-			nil,
-			[]uint64{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint256",
-			nil,
-			big.NewInt(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"uint256[]",
-			nil,
-			[]*big.Int{big.NewInt(1), big.NewInt(2)},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int8",
-			nil,
-			int8(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int8[]",
-			nil,
-			[]int8{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int16",
-			nil,
-			int16(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int16[]",
-			nil,
-			[]int16{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int32",
-			nil,
-			int32(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int32[]",
-			nil,
-			[]int32{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int64",
-			nil,
-			int64(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int64[]",
-			nil,
-			[]int64{1, 2},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int256",
-			nil,
-			big.NewInt(2),
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"int256[]",
-			nil,
-			[]*big.Int{big.NewInt(1), big.NewInt(2)},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002"),
-		},
-		{
-			"bytes1",
-			nil,
-			[1]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes2",
-			nil,
-			[2]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes3",
-			nil,
-			[3]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes4",
-			nil,
-			[4]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes5",
-			nil,
-			[5]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes6",
-			nil,
-			[6]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes7",
-			nil,
-			[7]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes8",
-			nil,
-			[8]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes9",
-			nil,
-			[9]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes10",
-			nil,
-			[10]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes11",
-			nil,
-			[11]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes12",
-			nil,
-			[12]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes13",
-			nil,
-			[13]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes14",
-			nil,
-			[14]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes15",
-			nil,
-			[15]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes16",
-			nil,
-			[16]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes17",
-			nil,
-			[17]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes18",
-			nil,
-			[18]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes19",
-			nil,
-			[19]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes20",
-			nil,
-			[20]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes21",
-			nil,
-			[21]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes22",
-			nil,
-			[22]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes23",
-			nil,
-			[23]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes24",
-			nil,
-			[24]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes25",
-			nil,
-			[25]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes26",
-			nil,
-			[26]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes27",
-			nil,
-			[27]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes28",
-			nil,
-			[28]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes29",
-			nil,
-			[29]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes30",
-			nil,
-			[30]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes31",
-			nil,
-			[31]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"bytes32",
-			nil,
-			[32]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"uint32[2][3][4]",
-			nil,
-			[4][3][2]uint32{{{1, 2}, {3, 4}, {5, 6}}, {{7, 8}, {9, 10}, {11, 12}}, {{13, 14}, {15, 16}, {17, 18}}, {{19, 20}, {21, 22}, {23, 24}}},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000170000000000000000000000000000000000000000000000000000000000000018"),
-		},
-		{
-			"address[]",
-			nil,
-			[]common.Address{{1}, {2}},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000200000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000"),
-		},
-		{
-			"bytes32[]",
-			nil,
-			[]common.Hash{{1}, {2}},
-			common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000201000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"function",
-			nil,
-			[24]byte{1},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"string",
-			nil,
-			"foobar",
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000006666f6f6261720000000000000000000000000000000000000000000000000000"),
-		},
-		{
-			"string[]",
-			nil,
-			[]string{"hello", "foobar"},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + // len(array) = 2
-				"0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
-				"0000000000000000000000000000000000000000000000000000000000000080" + // offset 128 to i = 1
-				"0000000000000000000000000000000000000000000000000000000000000005" + // len(str[0]) = 5
-				"68656c6c6f000000000000000000000000000000000000000000000000000000" + // str[0]
-				"0000000000000000000000000000000000000000000000000000000000000006" + // len(str[1]) = 6
-				"666f6f6261720000000000000000000000000000000000000000000000000000"), // str[1]
-		},
-		{
-			"string[2]",
-			nil,
-			[]string{"hello", "foobar"},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + // offset to i = 0
-				"0000000000000000000000000000000000000000000000000000000000000080" + // offset to i = 1
-				"0000000000000000000000000000000000000000000000000000000000000005" + // len(str[0]) = 5
-				"68656c6c6f000000000000000000000000000000000000000000000000000000" + // str[0]
-				"0000000000000000000000000000000000000000000000000000000000000006" + // len(str[1]) = 6
-				"666f6f6261720000000000000000000000000000000000000000000000000000"), // str[1]
-		},
-		{
-			"bytes32[][]",
-			nil,
-			[][]common.Hash{{{1}, {2}}, {{3}, {4}, {5}}},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + // len(array) = 2
-				"0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
-				"00000000000000000000000000000000000000000000000000000000000000a0" + // offset 160 to i = 1
-				"0000000000000000000000000000000000000000000000000000000000000002" + // len(array[0]) = 2
-				"0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
-				"0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
-				"0000000000000000000000000000000000000000000000000000000000000003" + // len(array[1]) = 3
-				"0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
-				"0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
-				"0500000000000000000000000000000000000000000000000000000000000000"), // array[1][2]
-		},
-
-		{
-			"bytes32[][2]",
-			nil,
-			[][]common.Hash{{{1}, {2}}, {{3}, {4}, {5}}},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + // offset 64 to i = 0
-				"00000000000000000000000000000000000000000000000000000000000000a0" + // offset 160 to i = 1
-				"0000000000000000000000000000000000000000000000000000000000000002" + // len(array[0]) = 2
-				"0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
-				"0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
-				"0000000000000000000000000000000000000000000000000000000000000003" + // len(array[1]) = 3
-				"0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
-				"0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
-				"0500000000000000000000000000000000000000000000000000000000000000"), // array[1][2]
-		},
-
-		{
-			"bytes32[3][2]",
-			nil,
-			[][]common.Hash{{{1}, {2}, {3}}, {{3}, {4}, {5}}},
-			common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000" + // array[0][0]
-				"0200000000000000000000000000000000000000000000000000000000000000" + // array[0][1]
-				"0300000000000000000000000000000000000000000000000000000000000000" + // array[0][2]
-				"0300000000000000000000000000000000000000000000000000000000000000" + // array[1][0]
-				"0400000000000000000000000000000000000000000000000000000000000000" + // array[1][1]
-				"0500000000000000000000000000000000000000000000000000000000000000"), // array[1][2]
-		},
-		{
-			// static tuple
-			"tuple",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "int64"},
-				{Name: "b", Type: "int256"},
-				{Name: "c", Type: "int256"},
-				{Name: "d", Type: "bool"},
-				{Name: "e", Type: "bytes32[3][2]"},
-			},
-			struct {
-				A int64
-				B *big.Int
-				C *big.Int
-				D bool
-				E [][]common.Hash
-			}{1, big.NewInt(1), big.NewInt(-1), true, [][]common.Hash{{{1}, {2}, {3}}, {{3}, {4}, {5}}}},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001" + // struct[a]
-				"0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // struct[c]
-				"0000000000000000000000000000000000000000000000000000000000000001" + // struct[d]
-				"0100000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][0]
-				"0200000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][1]
-				"0300000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[0][2]
-				"0300000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[1][0]
-				"0400000000000000000000000000000000000000000000000000000000000000" + // struct[e] array[1][1]
-				"0500000000000000000000000000000000000000000000000000000000000000"), // struct[e] array[1][2]
-		},
-		{
-			// dynamic tuple
-			"tuple",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "string"},
-				{Name: "b", Type: "int64"},
-				{Name: "c", Type: "bytes"},
-				{Name: "d", Type: "string[]"},
-				{Name: "e", Type: "int256[]"},
-				{Name: "f", Type: "address[]"},
-			},
-			struct {
-				FieldA string `abi:"a"` // Test whether abi tag works
-				FieldB int64  `abi:"b"`
-				C      []byte
-				D      []string
-				E      []*big.Int
-				F      []common.Address
-			}{"foobar", 1, []byte{1}, []string{"foo", "bar"}, []*big.Int{big.NewInt(1), big.NewInt(-1)}, []common.Address{{1}, {2}}},
-			common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000c0" + // struct[a] offset
-				"0000000000000000000000000000000000000000000000000000000000000001" + // struct[b]
-				"0000000000000000000000000000000000000000000000000000000000000100" + // struct[c] offset
-				"0000000000000000000000000000000000000000000000000000000000000140" + // struct[d] offset
-				"0000000000000000000000000000000000000000000000000000000000000220" + // struct[e] offset
-				"0000000000000000000000000000000000000000000000000000000000000280" + // struct[f] offset
-				"0000000000000000000000000000000000000000000000000000000000000006" + // struct[a] length
-				"666f6f6261720000000000000000000000000000000000000000000000000000" + // struct[a] "foobar"
-				"0000000000000000000000000000000000000000000000000000000000000001" + // struct[c] length
-				"0100000000000000000000000000000000000000000000000000000000000000" + // []byte{1}
-				"0000000000000000000000000000000000000000000000000000000000000002" + // struct[d] length
-				"0000000000000000000000000000000000000000000000000000000000000040" + // foo offset
-				"0000000000000000000000000000000000000000000000000000000000000080" + // bar offset
-				"0000000000000000000000000000000000000000000000000000000000000003" + // foo length
-				"666f6f0000000000000000000000000000000000000000000000000000000000" + // foo
-				"0000000000000000000000000000000000000000000000000000000000000003" + // bar offset
-				"6261720000000000000000000000000000000000000000000000000000000000" + // bar
-				"0000000000000000000000000000000000000000000000000000000000000002" + // struct[e] length
-				"0000000000000000000000000000000000000000000000000000000000000001" + // 1
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // -1
-				"0000000000000000000000000000000000000000000000000000000000000002" + // struct[f] length
-				"0000000000000000000000000100000000000000000000000000000000000000" + // common.Address{1}
-				"0000000000000000000000000200000000000000000000000000000000000000"), // common.Address{2}
-		},
-		{
-			// nested tuple
-			"tuple",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "tuple", Components: []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256[]"}}},
-				{Name: "b", Type: "int256[]"},
-			},
-			struct {
-				A struct {
-					FieldA *big.Int `abi:"a"`
-					B      []*big.Int
-				}
-				B []*big.Int
-			}{
-				A: struct {
-					FieldA *big.Int `abi:"a"` // Test whether abi tag works for nested tuple
-					B      []*big.Int
-				}{big.NewInt(1), []*big.Int{big.NewInt(1), big.NewInt(0)}},
-				B: []*big.Int{big.NewInt(1), big.NewInt(0)}},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + // a offset
-				"00000000000000000000000000000000000000000000000000000000000000e0" + // b offset
-				"0000000000000000000000000000000000000000000000000000000000000001" + // a.a value
-				"0000000000000000000000000000000000000000000000000000000000000040" + // a.b offset
-				"0000000000000000000000000000000000000000000000000000000000000002" + // a.b length
-				"0000000000000000000000000000000000000000000000000000000000000001" + // a.b[0] value
-				"0000000000000000000000000000000000000000000000000000000000000000" + // a.b[1] value
-				"0000000000000000000000000000000000000000000000000000000000000002" + // b length
-				"0000000000000000000000000000000000000000000000000000000000000001" + // b[0] value
-				"0000000000000000000000000000000000000000000000000000000000000000"), // b[1] value
-		},
-		{
-			// tuple slice
-			"tuple[]",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "int256"},
-				{Name: "b", Type: "int256[]"},
-			},
-			[]struct {
-				A *big.Int
-				B []*big.Int
-			}{
-				{big.NewInt(-1), []*big.Int{big.NewInt(1), big.NewInt(0)}},
-				{big.NewInt(1), []*big.Int{big.NewInt(2), big.NewInt(-1)}},
-			},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000002" + // tuple length
-				"0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0] offset
-				"00000000000000000000000000000000000000000000000000000000000000e0" + // tuple[1] offset
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].A
-				"0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0].B offset
-				"0000000000000000000000000000000000000000000000000000000000000002" + // tuple[0].B length
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].B[0] value
-				"0000000000000000000000000000000000000000000000000000000000000000" + // tuple[0].B[1] value
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].A
-				"0000000000000000000000000000000000000000000000000000000000000040" + // tuple[1].B offset
-				"0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].B length
-				"0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].B[0] value
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), // tuple[1].B[1] value
-		},
-		{
-			// static tuple array
-			"tuple[2]",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "int256"},
-				{Name: "b", Type: "int256"},
-			},
-			[2]struct {
-				A *big.Int
-				B *big.Int
-			}{
-				{big.NewInt(-1), big.NewInt(1)},
-				{big.NewInt(1), big.NewInt(-1)},
-			},
-			common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].a
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].b
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].a
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), // tuple[1].b
-		},
-		{
-			// dynamic tuple array
-			"tuple[2]",
-			[]ArgumentMarshaling{
-				{Name: "a", Type: "int256[]"},
-			},
-			[2]struct {
-				A []*big.Int
-			}{
-				{[]*big.Int{big.NewInt(-1), big.NewInt(1)}},
-				{[]*big.Int{big.NewInt(1), big.NewInt(-1)}},
-			},
-			common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040" + // tuple[0] offset
-				"00000000000000000000000000000000000000000000000000000000000000c0" + // tuple[1] offset
-				"0000000000000000000000000000000000000000000000000000000000000020" + // tuple[0].A offset
-				"0000000000000000000000000000000000000000000000000000000000000002" + // tuple[0].A length
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].A[0]
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].A[1]
-				"0000000000000000000000000000000000000000000000000000000000000020" + // tuple[1].A offset
-				"0000000000000000000000000000000000000000000000000000000000000002" + // tuple[1].A length
-				"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].A[0]
-				"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), // tuple[1].A[1]
-		},
-	} {
-		typ, err := NewType(test.typ, test.components)
-		if err != nil {
-			t.Fatalf("%v failed. Unexpected parse error: %v", i, err)
-		}
-		output, err := typ.pack(reflect.ValueOf(test.input))
-		if err != nil {
-			t.Fatalf("%v failed. Unexpected pack error: %v", i, err)
-		}
-
-		if !bytes.Equal(output, test.output) {
-			t.Errorf("input %d for typ: %v failed. Expected bytes: '%x' Got: '%x'", i, typ.String(), test.output, output)
-		}
-	}
-}
-
-func TestMethodPack(t *testing.T) {
-	abi, err := JSON(strings.NewReader(jsondata2))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sig := abi.Methods["slice"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-
-	packed, err := abi.Pack("slice", []uint32{1, 2})
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	var addrA, addrB = common.Address{1}, common.Address{2}
-	sig = abi.Methods["sliceAddress"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{32}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes(addrA[:], 32)...)
-	sig = append(sig, common.LeftPadBytes(addrB[:], 32)...)
-
-	packed, err = abi.Pack("sliceAddress", []common.Address{addrA, addrB})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	var addrC, addrD = common.Address{3}, common.Address{4}
-	sig = abi.Methods["sliceMultiAddress"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{64}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{160}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes(addrA[:], 32)...)
-	sig = append(sig, common.LeftPadBytes(addrB[:], 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes(addrC[:], 32)...)
-	sig = append(sig, common.LeftPadBytes(addrD[:], 32)...)
-
-	packed, err = abi.Pack("sliceMultiAddress", []common.Address{addrA, addrB}, []common.Address{addrC, addrD})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	sig = abi.Methods["slice256"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-
-	packed, err = abi.Pack("slice256", []*big.Int{big.NewInt(1), big.NewInt(2)})
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	a := [2][2]*big.Int{{big.NewInt(1), big.NewInt(1)}, {big.NewInt(2), big.NewInt(0)}}
-	sig = abi.Methods["nestedArray"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes(addrC[:], 32)...)
-	sig = append(sig, common.LeftPadBytes(addrD[:], 32)...)
-	packed, err = abi.Pack("nestedArray", a, []common.Address{addrC, addrD})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	sig = abi.Methods["nestedArray2"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0x80}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	packed, err = abi.Pack("nestedArray2", [2][]uint8{{1}, {1}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-
-	sig = abi.Methods["nestedSlice"].ID()
-	sig = append(sig, common.LeftPadBytes([]byte{0x20}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0x02}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0x40}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{0xa0}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
-	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
-	packed, err = abi.Pack("nestedSlice", [][]uint8{{1, 2}, {1, 2}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(packed, sig) {
-		t.Errorf("expected %x got %x", sig, packed)
-	}
-}
-
-func TestPackNumber(t *testing.T) {
-	tests := []struct {
-		value  reflect.Value
-		packed []byte
-	}{
-		// Protocol limits
-		{reflect.ValueOf(0), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000000")},
-		{reflect.ValueOf(1), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")},
-		{reflect.ValueOf(-1), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")},
-
-		// Type corner cases
-		{reflect.ValueOf(uint8(math.MaxUint8)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000000000ff")},
-		{reflect.ValueOf(uint16(math.MaxUint16)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000ffff")},
-		{reflect.ValueOf(uint32(math.MaxUint32)), common.Hex2Bytes("00000000000000000000000000000000000000000000000000000000ffffffff")},
-		{reflect.ValueOf(uint64(math.MaxUint64)), common.Hex2Bytes("000000000000000000000000000000000000000000000000ffffffffffffffff")},
-
-		{reflect.ValueOf(int8(math.MaxInt8)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000007f")},
-		{reflect.ValueOf(int16(math.MaxInt16)), common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000007fff")},
-		{reflect.ValueOf(int32(math.MaxInt32)), common.Hex2Bytes("000000000000000000000000000000000000000000000000000000007fffffff")},
-		{reflect.ValueOf(int64(math.MaxInt64)), common.Hex2Bytes("0000000000000000000000000000000000000000000000007fffffffffffffff")},
-
-		{reflect.ValueOf(int8(math.MinInt8)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80")},
-		{reflect.ValueOf(int16(math.MinInt16)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8000")},
-		{reflect.ValueOf(int32(math.MinInt32)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff80000000")},
-		{reflect.ValueOf(int64(math.MinInt64)), common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffff8000000000000000")},
-	}
-	for i, tt := range tests {
-		packed := packNum(tt.value)
-		if !bytes.Equal(packed, tt.packed) {
-			t.Errorf("test %d: pack mismatch: have %x, want %x", i, packed, tt.packed)
-		}
-	}
-}
--- a/accounts/abi/reflect.go
+++ b/accounts/abi/reflect.go
@ -1,226 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-)
-
-// indirect recursively dereferences the value until it either gets the value
-// or finds a big.Int
-func indirect(v reflect.Value) reflect.Value {
-	if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbigT {
-		return indirect(v.Elem())
-	}
-	return v
-}
-
-// indirectInterfaceOrPtr recursively dereferences the value until value is not interface.
-func indirectInterfaceOrPtr(v reflect.Value) reflect.Value {
-	if (v.Kind() == reflect.Interface || v.Kind() == reflect.Ptr) && v.Elem().IsValid() {
-		return indirect(v.Elem())
-	}
-	return v
-}
-
-// reflectIntKind returns the reflect using the given size and
-// unsignedness.
-func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) {
-	switch size {
-	case 8:
-		if unsigned {
-			return reflect.Uint8, uint8T
-		}
-		return reflect.Int8, int8T
-	case 16:
-		if unsigned {
-			return reflect.Uint16, uint16T
-		}
-		return reflect.Int16, int16T
-	case 32:
-		if unsigned {
-			return reflect.Uint32, uint32T
-		}
-		return reflect.Int32, int32T
-	case 64:
-		if unsigned {
-			return reflect.Uint64, uint64T
-		}
-		return reflect.Int64, int64T
-	}
-	return reflect.Ptr, bigT
-}
-
-// mustArrayToBytesSlice creates a new byte slice with the exact same size as value
-// and copies the bytes in value to the new slice.
-func mustArrayToByteSlice(value reflect.Value) reflect.Value {
-	slice := reflect.MakeSlice(reflect.TypeOf([]byte{}), value.Len(), value.Len())
-	reflect.Copy(slice, value)
-	return slice
-}
-
-// set attempts to assign src to dst by either setting, copying or otherwise.
-//
-// set is a bit more lenient when it comes to assignment and doesn't force an as
-// strict ruleset as bare `reflect` does.
-func set(dst, src reflect.Value) error {
-	dstType, srcType := dst.Type(), src.Type()
-	switch {
-	case dstType.Kind() == reflect.Interface && dst.Elem().IsValid():
-		return set(dst.Elem(), src)
-	case dstType.Kind() == reflect.Ptr && dstType.Elem() != derefbigT:
-		return set(dst.Elem(), src)
-	case srcType.AssignableTo(dstType) && dst.CanSet():
-		dst.Set(src)
-	case dstType.Kind() == reflect.Slice && srcType.Kind() == reflect.Slice:
-		return setSlice(dst, src)
-	default:
-		return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
-	}
-	return nil
-}
-
-// setSlice attempts to assign src to dst when slices are not assignable by default
-// e.g. src: [][]byte -> dst: [][15]byte
-func setSlice(dst, src reflect.Value) error {
-	slice := reflect.MakeSlice(dst.Type(), src.Len(), src.Len())
-	for i := 0; i < src.Len(); i++ {
-		v := src.Index(i)
-		reflect.Copy(slice.Index(i), v)
-	}
-
-	dst.Set(slice)
-	return nil
-}
-
-// requireAssignable assures that `dest` is a pointer and it's not an interface.
-func requireAssignable(dst, src reflect.Value) error {
-	if dst.Kind() != reflect.Ptr && dst.Kind() != reflect.Interface {
-		return fmt.Errorf("abi: cannot unmarshal %v into %v", src.Type(), dst.Type())
-	}
-	return nil
-}
-
-// requireUnpackKind verifies preconditions for unpacking `args` into `kind`
-func requireUnpackKind(v reflect.Value, t reflect.Type, k reflect.Kind,
-	args Arguments) error {
-
-	switch k {
-	case reflect.Struct:
-	case reflect.Slice, reflect.Array:
-		if minLen := args.LengthNonIndexed(); v.Len() < minLen {
-			return fmt.Errorf("abi: insufficient number of elements in the list/array for unpack, want %d, got %d",
-				minLen, v.Len())
-		}
-	default:
-		return fmt.Errorf("abi: cannot unmarshal tuple into %v", t)
-	}
-	return nil
-}
-
-// mapArgNamesToStructFields maps a slice of argument names to struct fields.
-// first round: for each Exportable field that contains a `abi:""` tag
-//   and this field name exists in the given argument name list, pair them together.
-// second round: for each argument name that has not been already linked,
-//   find what variable is expected to be mapped into, if it exists and has not been
-//   used, pair them.
-// Note this function assumes the given value is a struct value.
-func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[string]string, error) {
-	typ := value.Type()
-
-	abi2struct := make(map[string]string)
-	struct2abi := make(map[string]string)
-
-	// first round ~~~
-	for i := 0; i < typ.NumField(); i++ {
-		structFieldName := typ.Field(i).Name
-
-		// skip private struct fields.
-		if structFieldName[:1] != strings.ToUpper(structFieldName[:1]) {
-			continue
-		}
-		// skip fields that have no abi:"" tag.
-		var ok bool
-		var tagName string
-		if tagName, ok = typ.Field(i).Tag.Lookup("abi"); !ok {
-			continue
-		}
-		// check if tag is empty.
-		if tagName == "" {
-			return nil, fmt.Errorf("struct: abi tag in '%s' is empty", structFieldName)
-		}
-		// check which argument field matches with the abi tag.
-		found := false
-		for _, arg := range argNames {
-			if arg == tagName {
-				if abi2struct[arg] != "" {
-					return nil, fmt.Errorf("struct: abi tag in '%s' already mapped", structFieldName)
-				}
-				// pair them
-				abi2struct[arg] = structFieldName
-				struct2abi[structFieldName] = arg
-				found = true
-			}
-		}
-		// check if this tag has been mapped.
-		if !found {
-			return nil, fmt.Errorf("struct: abi tag '%s' defined but not found in abi", tagName)
-		}
-	}
-
-	// second round ~~~
-	for _, argName := range argNames {
-
-		structFieldName := ToCamelCase(argName)
-
-		if structFieldName == "" {
-			return nil, fmt.Errorf("abi: purely underscored output cannot unpack to struct")
-		}
-
-		// this abi has already been paired, skip it... unless there exists another, yet unassigned
-		// struct field with the same field name. If so, raise an error:
-		//    abi: [ { "name": "value" } ]
-		//    struct { Value  *big.Int , Value1 *big.Int `abi:"value"`}
-		if abi2struct[argName] != "" {
-			if abi2struct[argName] != structFieldName &&
-				struct2abi[structFieldName] == "" &&
-				value.FieldByName(structFieldName).IsValid() {
-				return nil, fmt.Errorf("abi: multiple variables maps to the same abi field '%s'", argName)
-			}
-			continue
-		}
-
-		// return an error if this struct field has already been paired.
-		if struct2abi[structFieldName] != "" {
-			return nil, fmt.Errorf("abi: multiple outputs mapping to the same struct field '%s'", structFieldName)
-		}
-
-		if value.FieldByName(structFieldName).IsValid() {
-			// pair them
-			abi2struct[argName] = structFieldName
-			struct2abi[structFieldName] = argName
-		} else {
-			// not paired, but annotate as used, to detect cases like
-			//   abi : [ { "name": "value" }, { "name": "_value" } ]
-			//   struct { Value *big.Int }
-			struct2abi[structFieldName] = argName
-		}
-	}
-	return abi2struct, nil
-}
--- a/accounts/abi/reflect_test.go
+++ b/accounts/abi/reflect_test.go
@ -1,191 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"reflect"
-	"testing"
-)
-
-type reflectTest struct {
-	name  string
-	args  []string
-	struc interface{}
-	want  map[string]string
-	err   string
-}
-
-var reflectTests = []reflectTest{
-	{
-		name: "OneToOneCorrespondance",
-		args: []string{"fieldA"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-		},
-	},
-	{
-		name: "MissingFieldsInStruct",
-		args: []string{"fieldA", "fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-		},
-	},
-	{
-		name: "MoreFieldsInStructThanArgs",
-		args: []string{"fieldA"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-			FieldB int
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-		},
-	},
-	{
-		name: "MissingFieldInArgs",
-		args: []string{"fieldA"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-			FieldB int `abi:"fieldB"`
-		}{},
-		err: "struct: abi tag 'fieldB' defined but not found in abi",
-	},
-	{
-		name: "NoAbiDescriptor",
-		args: []string{"fieldA"},
-		struc: struct {
-			FieldA int
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-		},
-	},
-	{
-		name: "NoArgs",
-		args: []string{},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-		}{},
-		err: "struct: abi tag 'fieldA' defined but not found in abi",
-	},
-	{
-		name: "DifferentName",
-		args: []string{"fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldB"`
-		}{},
-		want: map[string]string{
-			"fieldB": "FieldA",
-		},
-	},
-	{
-		name: "DifferentName",
-		args: []string{"fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldB"`
-		}{},
-		want: map[string]string{
-			"fieldB": "FieldA",
-		},
-	},
-	{
-		name: "MultipleFields",
-		args: []string{"fieldA", "fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-			FieldB int `abi:"fieldB"`
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-			"fieldB": "FieldB",
-		},
-	},
-	{
-		name: "MultipleFieldsABIMissing",
-		args: []string{"fieldA", "fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldA"`
-			FieldB int
-		}{},
-		want: map[string]string{
-			"fieldA": "FieldA",
-			"fieldB": "FieldB",
-		},
-	},
-	{
-		name: "NameConflict",
-		args: []string{"fieldB"},
-		struc: struct {
-			FieldA int `abi:"fieldB"`
-			FieldB int
-		}{},
-		err: "abi: multiple variables maps to the same abi field 'fieldB'",
-	},
-	{
-		name: "Underscored",
-		args: []string{"_"},
-		struc: struct {
-			FieldA int
-		}{},
-		err: "abi: purely underscored output cannot unpack to struct",
-	},
-	{
-		name: "DoubleMapping",
-		args: []string{"fieldB", "fieldC", "fieldA"},
-		struc: struct {
-			FieldA int `abi:"fieldC"`
-			FieldB int
-		}{},
-		err: "abi: multiple outputs mapping to the same struct field 'FieldA'",
-	},
-	{
-		name: "AlreadyMapped",
-		args: []string{"fieldB", "fieldB"},
-		struc: struct {
-			FieldB int `abi:"fieldB"`
-		}{},
-		err: "struct: abi tag in 'FieldB' already mapped",
-	},
-}
-
-func TestReflectNameToStruct(t *testing.T) {
-	for _, test := range reflectTests {
-		t.Run(test.name, func(t *testing.T) {
-			m, err := mapArgNamesToStructFields(test.args, reflect.ValueOf(test.struc))
-			if len(test.err) > 0 {
-				if err == nil || err.Error() != test.err {
-					t.Fatalf("Invalid error: expected %v, got %v", test.err, err)
-				}
-			} else {
-				if err != nil {
-					t.Fatalf("Unexpected error: %v", err)
-				}
-				for fname := range test.want {
-					if m[fname] != test.want[fname] {
-						t.Fatalf("Incorrect value for field %s: expected %v, got %v", fname, test.want[fname], m[fname])
-					}
-				}
-			}
-		})
-	}
-}
--- a/accounts/abi/type.go
+++ b/accounts/abi/type.go
@ -1,348 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// Type enumerator
-const (
-	IntTy byte = iota
-	UintTy
-	BoolTy
-	StringTy
-	SliceTy
-	ArrayTy
-	TupleTy
-	AddressTy
-	FixedBytesTy
-	BytesTy
-	HashTy
-	FixedPointTy
-	FunctionTy
-)
-
-// Type is the reflection of the supported argument type
-type Type struct {
-	Elem *Type
-	Kind reflect.Kind
-	Type reflect.Type
-	Size int
-	T    byte // Our own type checking
-
-	stringKind string // holds the unparsed string for deriving signatures
-
-	// Tuple relative fields
-	TupleElems    []*Type  // Type information of all tuple fields
-	TupleRawNames []string // Raw field name of all tuple fields
-}
-
-var (
-	// typeRegex parses the abi sub types
-	typeRegex = regexp.MustCompile("([a-zA-Z]+)(([0-9]+)(x([0-9]+))?)?")
-)
-
-// NewType creates a new reflection type of abi type given in t.
-func NewType(t string, components []ArgumentMarshaling) (typ Type, err error) {
-	// check that array brackets are equal if they exist
-	if strings.Count(t, "[") != strings.Count(t, "]") {
-		return Type{}, fmt.Errorf("invalid arg type in abi")
-	}
-	typ.stringKind = t
-
-	// if there are brackets, get ready to go into slice/array mode and
-	// recursively create the type
-	if strings.Count(t, "[") != 0 {
-		i := strings.LastIndex(t, "[")
-		// recursively embed the type
-		embeddedType, err := NewType(t[:i], components)
-		if err != nil {
-			return Type{}, err
-		}
-		// grab the last cell and create a type from there
-		sliced := t[i:]
-		// grab the slice size with regexp
-		re := regexp.MustCompile("[0-9]+")
-		intz := re.FindAllString(sliced, -1)
-
-		if len(intz) == 0 {
-			// is a slice
-			typ.T = SliceTy
-			typ.Kind = reflect.Slice
-			typ.Elem = &embeddedType
-			typ.Type = reflect.SliceOf(embeddedType.Type)
-			typ.stringKind = embeddedType.stringKind + sliced
-		} else if len(intz) == 1 {
-			// is a array
-			typ.T = ArrayTy
-			typ.Kind = reflect.Array
-			typ.Elem = &embeddedType
-			typ.Size, err = strconv.Atoi(intz[0])
-			if err != nil {
-				return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
-			}
-			typ.Type = reflect.ArrayOf(typ.Size, embeddedType.Type)
-			typ.stringKind = embeddedType.stringKind + sliced
-		} else {
-			return Type{}, fmt.Errorf("invalid formatting of array type")
-		}
-		return typ, err
-	}
-	// parse the type and size of the abi-type.
-	matches := typeRegex.FindAllStringSubmatch(t, -1)
-	if len(matches) == 0 {
-		return Type{}, fmt.Errorf("invalid type '%v'", t)
-	}
-	parsedType := matches[0]
-
-	// varSize is the size of the variable
-	var varSize int
-	if len(parsedType[3]) > 0 {
-		var err error
-		varSize, err = strconv.Atoi(parsedType[2])
-		if err != nil {
-			return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err)
-		}
-	} else {
-		if parsedType[0] == "uint" || parsedType[0] == "int" {
-			// this should fail because it means that there's something wrong with
-			// the abi type (the compiler should always format it to the size...always)
-			return Type{}, fmt.Errorf("unsupported arg type: %s", t)
-		}
-	}
-	// varType is the parsed abi type
-	switch varType := parsedType[1]; varType {
-	case "int":
-		typ.Kind, typ.Type = reflectIntKindAndType(false, varSize)
-		typ.Size = varSize
-		typ.T = IntTy
-	case "uint":
-		typ.Kind, typ.Type = reflectIntKindAndType(true, varSize)
-		typ.Size = varSize
-		typ.T = UintTy
-	case "bool":
-		typ.Kind = reflect.Bool
-		typ.T = BoolTy
-		typ.Type = reflect.TypeOf(bool(false))
-	case "address":
-		typ.Kind = reflect.Array
-		typ.Type = addressT
-		typ.Size = 20
-		typ.T = AddressTy
-	case "string":
-		typ.Kind = reflect.String
-		typ.Type = reflect.TypeOf("")
-		typ.T = StringTy
-	case "bytes":
-		if varSize == 0 {
-			typ.T = BytesTy
-			typ.Kind = reflect.Slice
-			typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0)))
-		} else {
-			typ.T = FixedBytesTy
-			typ.Kind = reflect.Array
-			typ.Size = varSize
-			typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0)))
-		}
-	case "tuple":
-		var (
-			fields     []reflect.StructField
-			elems      []*Type
-			names      []string
-			expression string // canonical parameter expression
-		)
-		expression += "("
-		for idx, c := range components {
-			cType, err := NewType(c.Type, c.Components)
-			if err != nil {
-				return Type{}, err
-			}
-			if ToCamelCase(c.Name) == "" {
-				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
-			}
-			fields = append(fields, reflect.StructField{
-				Name: ToCamelCase(c.Name), // reflect.StructOf will panic for any exported field.
-				Type: cType.Type,
-				Tag:  reflect.StructTag("json:\"" + c.Name + "\""),
-			})
-			elems = append(elems, &cType)
-			names = append(names, c.Name)
-			expression += cType.stringKind
-			if idx != len(components)-1 {
-				expression += ","
-			}
-		}
-		expression += ")"
-		typ.Kind = reflect.Struct
-		typ.Type = reflect.StructOf(fields)
-		typ.TupleElems = elems
-		typ.TupleRawNames = names
-		typ.T = TupleTy
-		typ.stringKind = expression
-	case "function":
-		typ.Kind = reflect.Array
-		typ.T = FunctionTy
-		typ.Size = 24
-		typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0)))
-	default:
-		return Type{}, fmt.Errorf("unsupported arg type: %s", t)
-	}
-
-	return
-}
-
-// String implements Stringer
-func (t Type) String() (out string) {
-	return t.stringKind
-}
-
-func (t Type) pack(v reflect.Value) ([]byte, error) {
-	// dereference pointer first if it's a pointer
-	v = indirect(v)
-	if err := typeCheck(t, v); err != nil {
-		return nil, err
-	}
-
-	switch t.T {
-	case SliceTy, ArrayTy:
-		var ret []byte
-
-		if t.requiresLengthPrefix() {
-			// append length
-			ret = append(ret, packNum(reflect.ValueOf(v.Len()))...)
-		}
-
-		// calculate offset if any
-		offset := 0
-		offsetReq := isDynamicType(*t.Elem)
-		if offsetReq {
-			offset = getTypeSize(*t.Elem) * v.Len()
-		}
-		var tail []byte
-		for i := 0; i < v.Len(); i++ {
-			val, err := t.Elem.pack(v.Index(i))
-			if err != nil {
-				return nil, err
-			}
-			if !offsetReq {
-				ret = append(ret, val...)
-				continue
-			}
-			ret = append(ret, packNum(reflect.ValueOf(offset))...)
-			offset += len(val)
-			tail = append(tail, val...)
-		}
-		return append(ret, tail...), nil
-	case TupleTy:
-		// (T1,...,Tk) for k >= 0 and any types T1, …, Tk
-		// enc(X) = head(X(1)) ... head(X(k)) tail(X(1)) ... tail(X(k))
-		// where X = (X(1), ..., X(k)) and head and tail are defined for Ti being a static
-		// type as
-		//     head(X(i)) = enc(X(i)) and tail(X(i)) = "" (the empty string)
-		// and as
-		//     head(X(i)) = enc(len(head(X(1)) ... head(X(k)) tail(X(1)) ... tail(X(i-1))))
-		//     tail(X(i)) = enc(X(i))
-		// otherwise, i.e. if Ti is a dynamic type.
-		fieldmap, err := mapArgNamesToStructFields(t.TupleRawNames, v)
-		if err != nil {
-			return nil, err
-		}
-		// Calculate prefix occupied size.
-		offset := 0
-		for _, elem := range t.TupleElems {
-			offset += getTypeSize(*elem)
-		}
-		var ret, tail []byte
-		for i, elem := range t.TupleElems {
-			field := v.FieldByName(fieldmap[t.TupleRawNames[i]])
-			if !field.IsValid() {
-				return nil, fmt.Errorf("field %s for tuple not found in the given struct", t.TupleRawNames[i])
-			}
-			val, err := elem.pack(field)
-			if err != nil {
-				return nil, err
-			}
-			if isDynamicType(*elem) {
-				ret = append(ret, packNum(reflect.ValueOf(offset))...)
-				tail = append(tail, val...)
-				offset += len(val)
-			} else {
-				ret = append(ret, val...)
-			}
-		}
-		return append(ret, tail...), nil
-
-	default:
-		return packElement(t, v), nil
-	}
-}
-
-// requireLengthPrefix returns whether the type requires any sort of length
-// prefixing.
-func (t Type) requiresLengthPrefix() bool {
-	return t.T == StringTy || t.T == BytesTy || t.T == SliceTy
-}
-
-// isDynamicType returns true if the type is dynamic.
-// The following types are called “dynamic”:
-// * bytes
-// * string
-// * T[] for any T
-// * T[k] for any dynamic T and any k >= 0
-// * (T1,...,Tk) if Ti is dynamic for some 1 <= i <= k
-func isDynamicType(t Type) bool {
-	if t.T == TupleTy {
-		for _, elem := range t.TupleElems {
-			if isDynamicType(*elem) {
-				return true
-			}
-		}
-		return false
-	}
-	return t.T == StringTy || t.T == BytesTy || t.T == SliceTy || (t.T == ArrayTy && isDynamicType(*t.Elem))
-}
-
-// getTypeSize returns the size that this type needs to occupy.
-// We distinguish static and dynamic types. Static types are encoded in-place
-// and dynamic types are encoded at a separately allocated location after the
-// current block.
-// So for a static variable, the size returned represents the size that the
-// variable actually occupies.
-// For a dynamic variable, the returned size is fixed 32 bytes, which is used
-// to store the location reference for actual value storage.
-func getTypeSize(t Type) int {
-	if t.T == ArrayTy && !isDynamicType(*t.Elem) {
-		// Recursively calculate type size if it is a nested array
-		if t.Elem.T == ArrayTy {
-			return t.Size * getTypeSize(*t.Elem)
-		}
-		return t.Size * 32
-	} else if t.T == TupleTy && !isDynamicType(t) {
-		total := 0
-		for _, elem := range t.TupleElems {
-			total += getTypeSize(*elem)
-		}
-		return total
-	}
-	return 32
-}
--- a/accounts/abi/type_test.go
+++ b/accounts/abi/type_test.go
@ -1,308 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"math/big"
-	"reflect"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// typeWithoutStringer is a alias for the Type type which simply doesn't implement
-// the stringer interface to allow printing type details in the tests below.
-type typeWithoutStringer Type
-
-// Tests that all allowed types get recognized by the type parser.
-func TestTypeRegexp(t *testing.T) {
-	tests := []struct {
-		blob       string
-		components []ArgumentMarshaling
-		kind       Type
-	}{
-		{"bool", nil, Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}},
-		{"bool[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool(nil)), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}},
-		{"bool[2]", nil, Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}},
-		{"bool[2][]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}},
-		{"bool[][]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}},
-		{"bool[][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}},
-		{"bool[2][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}},
-		{"bool[2][][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][][2]bool{}), Elem: &Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}, stringKind: "bool[2][][2]"}},
-		{"bool[2][2][2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][2]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}, stringKind: "bool[2][2][2]"}},
-		{"bool[][][]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}, stringKind: "bool[][][]"}},
-		{"bool[][2][]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][2][]bool{}), Elem: &Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]bool{}), Elem: &Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]bool{}), Elem: &Type{Kind: reflect.Bool, T: BoolTy, Type: reflect.TypeOf(bool(false)), stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}, stringKind: "bool[][2][]"}},
-		{"int8", nil, Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}},
-		{"int16", nil, Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}},
-		{"int32", nil, Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}},
-		{"int64", nil, Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}},
-		{"int256", nil, Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}},
-		{"int8[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}},
-		{"int8[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int8{}), Elem: &Type{Kind: reflect.Int8, Type: int8T, Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}},
-		{"int16[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}},
-		{"int16[2]", nil, Type{Size: 2, Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]int16{}), Elem: &Type{Kind: reflect.Int16, Type: int16T, Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}},
-		{"int32[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}},
-		{"int32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int32{}), Elem: &Type{Kind: reflect.Int32, Type: int32T, Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}},
-		{"int64[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}},
-		{"int64[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]int64{}), Elem: &Type{Kind: reflect.Int64, Type: int64T, Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}},
-		{"int256[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}},
-		{"int256[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}},
-		{"uint8", nil, Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}},
-		{"uint16", nil, Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}},
-		{"uint32", nil, Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}},
-		{"uint64", nil, Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}},
-		{"uint256", nil, Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}},
-		{"uint8[]", nil, Type{Kind: reflect.Slice, T: SliceTy, Type: reflect.TypeOf([]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}},
-		{"uint8[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint8{}), Elem: &Type{Kind: reflect.Uint8, Type: uint8T, Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}},
-		{"uint16[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}},
-		{"uint16[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint16{}), Elem: &Type{Kind: reflect.Uint16, Type: uint16T, Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}},
-		{"uint32[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}},
-		{"uint32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint32{}), Elem: &Type{Kind: reflect.Uint32, Type: uint32T, Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}},
-		{"uint64[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}},
-		{"uint64[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]uint64{}), Elem: &Type{Kind: reflect.Uint64, Type: uint64T, Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}},
-		{"uint256[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]*big.Int{}), Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}},
-		{"uint256[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Type: reflect.TypeOf([2]*big.Int{}), Size: 2, Elem: &Type{Kind: reflect.Ptr, Type: bigT, Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}},
-		{"bytes32", nil, Type{Kind: reflect.Array, T: FixedBytesTy, Size: 32, Type: reflect.TypeOf([32]byte{}), stringKind: "bytes32"}},
-		{"bytes[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][]byte{}), Elem: &Type{Kind: reflect.Slice, Type: reflect.TypeOf([]byte{}), T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}},
-		{"bytes[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][]byte{}), Elem: &Type{T: BytesTy, Type: reflect.TypeOf([]byte{}), Kind: reflect.Slice, stringKind: "bytes"}, stringKind: "bytes[2]"}},
-		{"bytes32[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([][32]byte{}), Elem: &Type{Kind: reflect.Array, Type: reflect.TypeOf([32]byte{}), T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[]"}},
-		{"bytes32[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2][32]byte{}), Elem: &Type{Kind: reflect.Array, T: FixedBytesTy, Size: 32, Type: reflect.TypeOf([32]byte{}), stringKind: "bytes32"}, stringKind: "bytes32[2]"}},
-		{"string", nil, Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}},
-		{"string[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]string{}), Elem: &Type{Kind: reflect.String, Type: reflect.TypeOf(""), T: StringTy, stringKind: "string"}, stringKind: "string[]"}},
-		{"string[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]string{}), Elem: &Type{Kind: reflect.String, T: StringTy, Type: reflect.TypeOf(""), stringKind: "string"}, stringKind: "string[2]"}},
-		{"address", nil, Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}},
-		{"address[]", nil, Type{T: SliceTy, Kind: reflect.Slice, Type: reflect.TypeOf([]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}},
-		{"address[2]", nil, Type{Kind: reflect.Array, T: ArrayTy, Size: 2, Type: reflect.TypeOf([2]common.Address{}), Elem: &Type{Kind: reflect.Array, Type: addressT, Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}},
-		// TODO when fixed types are implemented properly
-		// {"fixed", nil, Type{}},
-		// {"fixed128x128", nil, Type{}},
-		// {"fixed[]", nil, Type{}},
-		// {"fixed[2]", nil, Type{}},
-		// {"fixed128x128[]", nil, Type{}},
-		// {"fixed128x128[2]", nil, Type{}},
-		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "int64"}}, Type{Kind: reflect.Struct, T: TupleTy, Type: reflect.TypeOf(struct {
-			A int64 `json:"a"`
-		}{}), stringKind: "(int64)",
-			TupleElems: []*Type{{Kind: reflect.Int64, T: IntTy, Type: reflect.TypeOf(int64(0)), Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"a"}}},
-		{"tuple with long name", []ArgumentMarshaling{{Name: "aTypicalParamName", Type: "int64"}}, Type{Kind: reflect.Struct, T: TupleTy, Type: reflect.TypeOf(struct {
-			ATypicalParamName int64 `json:"aTypicalParamName"`
-		}{}), stringKind: "(int64)",
-			TupleElems: []*Type{{Kind: reflect.Int64, T: IntTy, Type: reflect.TypeOf(int64(0)), Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"aTypicalParamName"}}},
-	}
-
-	for _, tt := range tests {
-		typ, err := NewType(tt.blob, tt.components)
-		if err != nil {
-			t.Errorf("type %q: failed to parse type string: %v", tt.blob, err)
-		}
-		if !reflect.DeepEqual(typ, tt.kind) {
-			t.Errorf("type %q: parsed type mismatch:\nGOT %s\nWANT %s ", tt.blob, spew.Sdump(typeWithoutStringer(typ)), spew.Sdump(typeWithoutStringer(tt.kind)))
-		}
-	}
-}
-
-func TestTypeCheck(t *testing.T) {
-	for i, test := range []struct {
-		typ        string
-		components []ArgumentMarshaling
-		input      interface{}
-		err        string
-	}{
-		{"uint", nil, big.NewInt(1), "unsupported arg type: uint"},
-		{"int", nil, big.NewInt(1), "unsupported arg type: int"},
-		{"uint256", nil, big.NewInt(1), ""},
-		{"uint256[][3][]", nil, [][3][]*big.Int{{{}}}, ""},
-		{"uint256[][][3]", nil, [3][][]*big.Int{{{}}}, ""},
-		{"uint256[3][][]", nil, [][][3]*big.Int{{{}}}, ""},
-		{"uint256[3][3][3]", nil, [3][3][3]*big.Int{{{}}}, ""},
-		{"uint8[][]", nil, [][]uint8{}, ""},
-		{"int256", nil, big.NewInt(1), ""},
-		{"uint8", nil, uint8(1), ""},
-		{"uint16", nil, uint16(1), ""},
-		{"uint32", nil, uint32(1), ""},
-		{"uint64", nil, uint64(1), ""},
-		{"int8", nil, int8(1), ""},
-		{"int16", nil, int16(1), ""},
-		{"int32", nil, int32(1), ""},
-		{"int64", nil, int64(1), ""},
-		{"uint24", nil, big.NewInt(1), ""},
-		{"uint40", nil, big.NewInt(1), ""},
-		{"uint48", nil, big.NewInt(1), ""},
-		{"uint56", nil, big.NewInt(1), ""},
-		{"uint72", nil, big.NewInt(1), ""},
-		{"uint80", nil, big.NewInt(1), ""},
-		{"uint88", nil, big.NewInt(1), ""},
-		{"uint96", nil, big.NewInt(1), ""},
-		{"uint104", nil, big.NewInt(1), ""},
-		{"uint112", nil, big.NewInt(1), ""},
-		{"uint120", nil, big.NewInt(1), ""},
-		{"uint128", nil, big.NewInt(1), ""},
-		{"uint136", nil, big.NewInt(1), ""},
-		{"uint144", nil, big.NewInt(1), ""},
-		{"uint152", nil, big.NewInt(1), ""},
-		{"uint160", nil, big.NewInt(1), ""},
-		{"uint168", nil, big.NewInt(1), ""},
-		{"uint176", nil, big.NewInt(1), ""},
-		{"uint184", nil, big.NewInt(1), ""},
-		{"uint192", nil, big.NewInt(1), ""},
-		{"uint200", nil, big.NewInt(1), ""},
-		{"uint208", nil, big.NewInt(1), ""},
-		{"uint216", nil, big.NewInt(1), ""},
-		{"uint224", nil, big.NewInt(1), ""},
-		{"uint232", nil, big.NewInt(1), ""},
-		{"uint240", nil, big.NewInt(1), ""},
-		{"uint248", nil, big.NewInt(1), ""},
-		{"int24", nil, big.NewInt(1), ""},
-		{"int40", nil, big.NewInt(1), ""},
-		{"int48", nil, big.NewInt(1), ""},
-		{"int56", nil, big.NewInt(1), ""},
-		{"int72", nil, big.NewInt(1), ""},
-		{"int80", nil, big.NewInt(1), ""},
-		{"int88", nil, big.NewInt(1), ""},
-		{"int96", nil, big.NewInt(1), ""},
-		{"int104", nil, big.NewInt(1), ""},
-		{"int112", nil, big.NewInt(1), ""},
-		{"int120", nil, big.NewInt(1), ""},
-		{"int128", nil, big.NewInt(1), ""},
-		{"int136", nil, big.NewInt(1), ""},
-		{"int144", nil, big.NewInt(1), ""},
-		{"int152", nil, big.NewInt(1), ""},
-		{"int160", nil, big.NewInt(1), ""},
-		{"int168", nil, big.NewInt(1), ""},
-		{"int176", nil, big.NewInt(1), ""},
-		{"int184", nil, big.NewInt(1), ""},
-		{"int192", nil, big.NewInt(1), ""},
-		{"int200", nil, big.NewInt(1), ""},
-		{"int208", nil, big.NewInt(1), ""},
-		{"int216", nil, big.NewInt(1), ""},
-		{"int224", nil, big.NewInt(1), ""},
-		{"int232", nil, big.NewInt(1), ""},
-		{"int240", nil, big.NewInt(1), ""},
-		{"int248", nil, big.NewInt(1), ""},
-		{"uint30", nil, uint8(1), "abi: cannot use uint8 as type ptr as argument"},
-		{"uint8", nil, uint16(1), "abi: cannot use uint16 as type uint8 as argument"},
-		{"uint8", nil, uint32(1), "abi: cannot use uint32 as type uint8 as argument"},
-		{"uint8", nil, uint64(1), "abi: cannot use uint64 as type uint8 as argument"},
-		{"uint8", nil, int8(1), "abi: cannot use int8 as type uint8 as argument"},
-		{"uint8", nil, int16(1), "abi: cannot use int16 as type uint8 as argument"},
-		{"uint8", nil, int32(1), "abi: cannot use int32 as type uint8 as argument"},
-		{"uint8", nil, int64(1), "abi: cannot use int64 as type uint8 as argument"},
-		{"uint16", nil, uint16(1), ""},
-		{"uint16", nil, uint8(1), "abi: cannot use uint8 as type uint16 as argument"},
-		{"uint16[]", nil, []uint16{1, 2, 3}, ""},
-		{"uint16[]", nil, [3]uint16{1, 2, 3}, ""},
-		{"uint16[]", nil, []uint32{1, 2, 3}, "abi: cannot use []uint32 as type [0]uint16 as argument"},
-		{"uint16[3]", nil, [3]uint32{1, 2, 3}, "abi: cannot use [3]uint32 as type [3]uint16 as argument"},
-		{"uint16[3]", nil, [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
-		{"uint16[3]", nil, []uint16{1, 2, 3}, ""},
-		{"uint16[3]", nil, []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
-		{"address[]", nil, []common.Address{{1}}, ""},
-		{"address[1]", nil, []common.Address{{1}}, ""},
-		{"address[1]", nil, [1]common.Address{{1}}, ""},
-		{"address[2]", nil, [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
-		{"bytes32", nil, [32]byte{}, ""},
-		{"bytes31", nil, [31]byte{}, ""},
-		{"bytes30", nil, [30]byte{}, ""},
-		{"bytes29", nil, [29]byte{}, ""},
-		{"bytes28", nil, [28]byte{}, ""},
-		{"bytes27", nil, [27]byte{}, ""},
-		{"bytes26", nil, [26]byte{}, ""},
-		{"bytes25", nil, [25]byte{}, ""},
-		{"bytes24", nil, [24]byte{}, ""},
-		{"bytes23", nil, [23]byte{}, ""},
-		{"bytes22", nil, [22]byte{}, ""},
-		{"bytes21", nil, [21]byte{}, ""},
-		{"bytes20", nil, [20]byte{}, ""},
-		{"bytes19", nil, [19]byte{}, ""},
-		{"bytes18", nil, [18]byte{}, ""},
-		{"bytes17", nil, [17]byte{}, ""},
-		{"bytes16", nil, [16]byte{}, ""},
-		{"bytes15", nil, [15]byte{}, ""},
-		{"bytes14", nil, [14]byte{}, ""},
-		{"bytes13", nil, [13]byte{}, ""},
-		{"bytes12", nil, [12]byte{}, ""},
-		{"bytes11", nil, [11]byte{}, ""},
-		{"bytes10", nil, [10]byte{}, ""},
-		{"bytes9", nil, [9]byte{}, ""},
-		{"bytes8", nil, [8]byte{}, ""},
-		{"bytes7", nil, [7]byte{}, ""},
-		{"bytes6", nil, [6]byte{}, ""},
-		{"bytes5", nil, [5]byte{}, ""},
-		{"bytes4", nil, [4]byte{}, ""},
-		{"bytes3", nil, [3]byte{}, ""},
-		{"bytes2", nil, [2]byte{}, ""},
-		{"bytes1", nil, [1]byte{}, ""},
-		{"bytes32", nil, [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
-		{"bytes32", nil, common.Hash{1}, ""},
-		{"bytes31", nil, common.Hash{1}, "abi: cannot use common.Hash as type [31]uint8 as argument"},
-		{"bytes31", nil, [32]byte{}, "abi: cannot use [32]uint8 as type [31]uint8 as argument"},
-		{"bytes", nil, []byte{0, 1}, ""},
-		{"bytes", nil, [2]byte{0, 1}, "abi: cannot use array as type slice as argument"},
-		{"bytes", nil, common.Hash{1}, "abi: cannot use array as type slice as argument"},
-		{"string", nil, "hello world", ""},
-		{"string", nil, string(""), ""},
-		{"string", nil, []byte{}, "abi: cannot use slice as type string as argument"},
-		{"bytes32[]", nil, [][32]byte{{}}, ""},
-		{"function", nil, [24]byte{}, ""},
-		{"bytes20", nil, common.Address{}, ""},
-		{"address", nil, [20]byte{}, ""},
-		{"address", nil, common.Address{}, ""},
-		{"bytes32[]]", nil, "", "invalid arg type in abi"},
-		{"invalidType", nil, "", "unsupported arg type: invalidType"},
-		{"invalidSlice[]", nil, "", "unsupported arg type: invalidSlice"},
-		// simple tuple
-		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, struct {
-			A *big.Int
-			B *big.Int
-		}{}, ""},
-		// tuple slice
-		{"tuple[]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
-			A *big.Int
-			B *big.Int
-		}{}, ""},
-		// tuple array
-		{"tuple[2]", []ArgumentMarshaling{{Name: "a", Type: "uint256"}, {Name: "b", Type: "uint256"}}, []struct {
-			A *big.Int
-			B *big.Int
-		}{{big.NewInt(0), big.NewInt(0)}, {big.NewInt(0), big.NewInt(0)}}, ""},
-	} {
-		typ, err := NewType(test.typ, test.components)
-		if err != nil && len(test.err) == 0 {
-			t.Fatal("unexpected parse error:", err)
-		} else if err != nil && len(test.err) != 0 {
-			if err.Error() != test.err {
-				t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
-			}
-			continue
-		}
-
-		err = typeCheck(typ, reflect.ValueOf(test.input))
-		if err != nil && len(test.err) == 0 {
-			t.Errorf("%d failed. Expected no err but got: %v", i, err)
-			continue
-		}
-		if err == nil && len(test.err) != 0 {
-			t.Errorf("%d failed. Expected err: %v but got none", i, test.err)
-			continue
-		}
-
-		if err != nil && len(test.err) != 0 && err.Error() != test.err {
-			t.Errorf("%d failed. Expected err: '%v' got err: '%v'", i, test.err, err)
-		}
-	}
-}
--- a/accounts/abi/unpack_test.go
+++ b/accounts/abi/unpack_test.go
--- a/accounts/accounts_test.go
+++ b/accounts/accounts_test.go
@ -1,32 +0,0 @@
-// Copyright 2015 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package accounts
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-)
-
-func TestTextHash(t *testing.T) {
-	hash := TextHash([]byte("Hello Joe"))
-	want := hexutil.MustDecode("0xa080337ae51c4e064c189e113edd0ba391df9206e2f49db658bb32cf2911730b")
-	if !bytes.Equal(hash, want) {
-		t.Fatalf("wrong hash: %x", hash)
-	}
-}
--- a/accounts/errors.go
+++ b/accounts/errors.go
@ -1,68 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package accounts
-
-import (
-	"errors"
-	"fmt"
-)
-
-// ErrUnknownAccount is returned for any requested operation for which no backend
-// provides the specified account.
-var ErrUnknownAccount = errors.New("unknown account")
-
-// ErrUnknownWallet is returned for any requested operation for which no backend
-// provides the specified wallet.
-var ErrUnknownWallet = errors.New("unknown wallet")
-
-// ErrNotSupported is returned when an operation is requested from an account
-// backend that it does not support.
-var ErrNotSupported = errors.New("not supported")
-
-// ErrInvalidPassphrase is returned when a decryption operation receives a bad
-// passphrase.
-var ErrInvalidPassphrase = errors.New("invalid password")
-
-// ErrWalletAlreadyOpen is returned if a wallet is attempted to be opened the
-// second time.
-var ErrWalletAlreadyOpen = errors.New("wallet already open")
-
-// ErrWalletClosed is returned if a wallet is attempted to be opened the
-// secodn time.
-var ErrWalletClosed = errors.New("wallet closed")
-
-// AuthNeededError is returned by backends for signing requests where the user
-// is required to provide further authentication before signing can succeed.
-//
-// This usually means either that a password needs to be supplied, or perhaps a
-// one time PIN code displayed by some hardware device.
-type AuthNeededError struct {
-	Needed string // Extra authentication the user needs to provide
-}
-
-// NewAuthNeededError creates a new authentication error with the extra details
-// about the needed fields set.
-func NewAuthNeededError(needed string) error {
-	return &AuthNeededError{
-		Needed: needed,
-	}
-}
-
-// Error implements the standard error interface.
-func (err *AuthNeededError) Error() string {
-	return fmt.Sprintf("authentication needed: %s", err.Needed)
-}
--- a/accounts/external/backend.go
+++ b/accounts/external/backend.go
@ -1,231 +0,0 @@
-// Copyright 2019 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package external
-
-import (
-	"fmt"
-	"math/big"
-	"sync"
-
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/internal/ethapi"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/rpc"
-	"github.com/ethereum/go-ethereum/signer/core"
-)
-
-type ExternalBackend struct {
-	signers []accounts.Wallet
-}
-
-func (eb *ExternalBackend) Wallets() []accounts.Wallet {
-	return eb.signers
-}
-
-func NewExternalBackend(endpoint string) (*ExternalBackend, error) {
-	signer, err := NewExternalSigner(endpoint)
-	if err != nil {
-		return nil, err
-	}
-	return &ExternalBackend{
-		signers: []accounts.Wallet{signer},
-	}, nil
-}
-
-func (eb *ExternalBackend) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
-	return event.NewSubscription(func(quit <-chan struct{}) error {
-		<-quit
-		return nil
-	})
-}
-
-// ExternalSigner provides an API to interact with an external signer (clef)
-// It proxies request to the external signer while forwarding relevant
-// request headers
-type ExternalSigner struct {
-	client   *rpc.Client
-	endpoint string
-	status   string
-	cacheMu  sync.RWMutex
-	cache    []accounts.Account
-}
-
-func NewExternalSigner(endpoint string) (*ExternalSigner, error) {
-	client, err := rpc.Dial(endpoint)
-	if err != nil {
-		return nil, err
-	}
-	extsigner := &ExternalSigner{
-		client:   client,
-		endpoint: endpoint,
-	}
-	// Check if reachable
-	version, err := extsigner.pingVersion()
-	if err != nil {
-		return nil, err
-	}
-	extsigner.status = fmt.Sprintf("ok [version=%v]", version)
-	return extsigner, nil
-}
-
-func (api *ExternalSigner) URL() accounts.URL {
-	return accounts.URL{
-		Scheme: "extapi",
-		Path:   api.endpoint,
-	}
-}
-
-func (api *ExternalSigner) Status() (string, error) {
-	return api.status, nil
-}
-
-func (api *ExternalSigner) Open(passphrase string) error {
-	return fmt.Errorf("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) Close() error {
-	return fmt.Errorf("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) Accounts() []accounts.Account {
-	var accnts []accounts.Account
-	res, err := api.listAccounts()
-	if err != nil {
-		log.Error("account listing failed", "error", err)
-		return accnts
-	}
-	for _, addr := range res {
-		accnts = append(accnts, accounts.Account{
-			URL: accounts.URL{
-				Scheme: "extapi",
-				Path:   api.endpoint,
-			},
-			Address: addr,
-		})
-	}
-	api.cacheMu.Lock()
-	api.cache = accnts
-	api.cacheMu.Unlock()
-	return accnts
-}
-
-func (api *ExternalSigner) Contains(account accounts.Account) bool {
-	api.cacheMu.RLock()
-	defer api.cacheMu.RUnlock()
-	for _, a := range api.cache {
-		if a.Address == account.Address && (account.URL == (accounts.URL{}) || account.URL == api.URL()) {
-			return true
-		}
-	}
-	return false
-}
-
-func (api *ExternalSigner) Derive(path accounts.DerivationPath, pin bool) (accounts.Account, error) {
-	return accounts.Account{}, fmt.Errorf("operation not supported on external signers")
-}
-
-func (api *ExternalSigner) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
-	log.Error("operation SelfDerive not supported on external signers")
-}
-
-func (api *ExternalSigner) signHash(account accounts.Account, hash []byte) ([]byte, error) {
-	return []byte{}, fmt.Errorf("operation not supported on external signers")
-}
-
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
-func (api *ExternalSigner) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
-	var res hexutil.Bytes
-	var signAddress = common.NewMixedcaseAddress(account.Address)
-	if err := api.client.Call(&res, "account_signData",
-		mimeType,
-		&signAddress, // Need to use the pointer here, because of how MarshalJSON is defined
-		hexutil.Encode(data)); err != nil {
-		return nil, err
-	}
-	// If V is on 27/28-form, convert to to 0/1 for Clique
-	if mimeType == accounts.MimetypeClique && (res[64] == 27 || res[64] == 28) {
-		res[64] -= 27 // Transform V from 27/28 to 0/1 for Clique use
-	}
-	return res, nil
-}
-
-func (api *ExternalSigner) SignText(account accounts.Account, text []byte) ([]byte, error) {
-	var res hexutil.Bytes
-	var signAddress = common.NewMixedcaseAddress(account.Address)
-	if err := api.client.Call(&res, "account_signData",
-		accounts.MimetypeTextPlain,
-		&signAddress, // Need to use the pointer here, because of how MarshalJSON is defined
-		hexutil.Encode(text)); err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	res := ethapi.SignTransactionResult{}
-	data := hexutil.Bytes(tx.Data())
-	var to *common.MixedcaseAddress
-	if tx.To() != nil {
-		t := common.NewMixedcaseAddress(*tx.To())
-		to = &t
-	}
-	args := &core.SendTxArgs{
-		Data:     &data,
-		Nonce:    hexutil.Uint64(tx.Nonce()),
-		Value:    hexutil.Big(*tx.Value()),
-		Gas:      hexutil.Uint64(tx.Gas()),
-		GasPrice: hexutil.Big(*tx.GasPrice()),
-		To:       to,
-		From:     common.NewMixedcaseAddress(account.Address),
-	}
-	if err := api.client.Call(&res, "account_signTransaction", args); err != nil {
-		return nil, err
-	}
-	return res.Tx, nil
-}
-
-func (api *ExternalSigner) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
-	return []byte{}, fmt.Errorf("password-operations not supported on external signers")
-}
-
-func (api *ExternalSigner) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	return nil, fmt.Errorf("password-operations not supported on external signers")
-}
-func (api *ExternalSigner) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
-	return nil, fmt.Errorf("password-operations not supported on external signers")
-}
-
-func (api *ExternalSigner) listAccounts() ([]common.Address, error) {
-	var res []common.Address
-	if err := api.client.Call(&res, "account_list"); err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (api *ExternalSigner) pingVersion() (string, error) {
-	var v string
-	if err := api.client.Call(&v, "account_version"); err != nil {
-		return "", err
-	}
-	return v, nil
-}
--- a/accounts/hd_test.go
+++ b/accounts/hd_test.go
@ -1,79 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package accounts
-
-import (
-	"reflect"
-	"testing"
-)
-
-// Tests that HD derivation paths can be correctly parsed into our internal binary
-// representation.
-func TestHDPathParsing(t *testing.T) {
-	tests := []struct {
-		input  string
-		output DerivationPath
-	}{
-		// Plain absolute derivation paths
-		{"m/44'/60'/0'/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-		{"m/44'/60'/0'/128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}},
-		{"m/44'/60'/0'/0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-		{"m/44'/60'/0'/128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}},
-		{"m/2147483692/2147483708/2147483648/0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-		{"m/2147483692/2147483708/2147483648/2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-
-		// Plain relative derivation paths
-		{"0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}},
-		{"128", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}},
-		{"0'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-		{"128'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}},
-		{"2147483648", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-
-		// Hexadecimal absolute derivation paths
-		{"m/0x2C'/0x3c'/0x00'/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-		{"m/0x2C'/0x3c'/0x00'/0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 128}},
-		{"m/0x2C'/0x3c'/0x00'/0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-		{"m/0x2C'/0x3c'/0x00'/0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 128}},
-		{"m/0x8000002C/0x8000003c/0x80000000/0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-		{"m/0x8000002C/0x8000003c/0x80000000/0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0x80000000 + 0}},
-
-		// Hexadecimal relative derivation paths
-		{"0x00", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}},
-		{"0x80", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 128}},
-		{"0x00'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-		{"0x80'", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 128}},
-		{"0x80000000", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0x80000000 + 0}},
-
-		// Weird inputs just to ensure they work
-		{"	m  /   44			'\n/\n   60	\n\n\t'   /\n0 ' /\t\t	0", DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}},
-
-		// Invaid derivation paths
-		{"", nil},              // Empty relative derivation path
-		{"m", nil},             // Empty absolute derivation path
-		{"m/", nil},            // Missing last derivation component
-		{"/44'/60'/0'/0", nil}, // Absolute path without m prefix, might be user error
-		{"m/2147483648'", nil}, // Overflows 32 bit integer
-		{"m/-1'", nil},         // Cannot contain negative number
-	}
-	for i, tt := range tests {
-		if path, err := ParseDerivationPath(tt.input); !reflect.DeepEqual(path, tt.output) {
-			t.Errorf("test %d: parse mismatch: have %v (%v), want %v", i, path, err, tt.output)
-		} else if path == nil && err == nil {
-			t.Errorf("test %d: nil path and error: %v", i, err)
-		}
-	}
-}
--- a/accounts/keystore/account_cache_test.go
+++ b/accounts/keystore/account_cache_test.go
@ -1,406 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package keystore
-
-import (
-	"fmt"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"reflect"
-	"sort"
-	"testing"
-	"time"
-
-	"github.com/cespare/cp"
-	"github.com/davecgh/go-spew/spew"
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-)
-
-var (
-	cachetestDir, _   = filepath.Abs(filepath.Join("testdata", "keystore"))
-	cachetestAccounts = []accounts.Account{
-		{
-			Address: common.HexToAddress("7ef5a6135f1fd6a02593eedc869c6d41d934aef8"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8")},
-		},
-		{
-			Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "aaa")},
-		},
-		{
-			Address: common.HexToAddress("289d485d9771714cce91d3393d764e1311907acc"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(cachetestDir, "zzz")},
-		},
-	}
-)
-
-func TestWatchNewFile(t *testing.T) {
-	t.Parallel()
-
-	dir, ks := tmpKeyStore(t, false)
-	defer os.RemoveAll(dir)
-
-	// Ensure the watcher is started before adding any files.
-	ks.Accounts()
-	time.Sleep(1000 * time.Millisecond)
-
-	// Move in the files.
-	wantAccounts := make([]accounts.Account, len(cachetestAccounts))
-	for i := range cachetestAccounts {
-		wantAccounts[i] = accounts.Account{
-			Address: cachetestAccounts[i].Address,
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, filepath.Base(cachetestAccounts[i].URL.Path))},
-		}
-		if err := cp.CopyFile(wantAccounts[i].URL.Path, cachetestAccounts[i].URL.Path); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// ks should see the accounts.
-	var list []accounts.Account
-	for d := 200 * time.Millisecond; d < 5*time.Second; d *= 2 {
-		list = ks.Accounts()
-		if reflect.DeepEqual(list, wantAccounts) {
-			// ks should have also received change notifications
-			select {
-			case <-ks.changes:
-			default:
-				t.Fatalf("wasn't notified of new accounts")
-			}
-			return
-		}
-		time.Sleep(d)
-	}
-	t.Errorf("got %s, want %s", spew.Sdump(list), spew.Sdump(wantAccounts))
-}
-
-func TestWatchNoDir(t *testing.T) {
-	t.Parallel()
-
-	// Create ks but not the directory that it watches.
-	rand.Seed(time.Now().UnixNano())
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watch-test-%d-%d", os.Getpid(), rand.Int()))
-	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
-
-	list := ks.Accounts()
-	if len(list) > 0 {
-		t.Error("initial account list not empty:", list)
-	}
-	time.Sleep(100 * time.Millisecond)
-
-	// Create the directory and copy a key file into it.
-	os.MkdirAll(dir, 0700)
-	defer os.RemoveAll(dir)
-	file := filepath.Join(dir, "aaa")
-	if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
-		t.Fatal(err)
-	}
-
-	// ks should see the account.
-	wantAccounts := []accounts.Account{cachetestAccounts[0]}
-	wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
-	for d := 200 * time.Millisecond; d < 8*time.Second; d *= 2 {
-		list = ks.Accounts()
-		if reflect.DeepEqual(list, wantAccounts) {
-			// ks should have also received change notifications
-			select {
-			case <-ks.changes:
-			default:
-				t.Fatalf("wasn't notified of new accounts")
-			}
-			return
-		}
-		time.Sleep(d)
-	}
-	t.Errorf("\ngot  %v\nwant %v", list, wantAccounts)
-}
-
-func TestCacheInitialReload(t *testing.T) {
-	cache, _ := newAccountCache(cachetestDir)
-	accounts := cache.accounts()
-	if !reflect.DeepEqual(accounts, cachetestAccounts) {
-		t.Fatalf("got initial accounts: %swant %s", spew.Sdump(accounts), spew.Sdump(cachetestAccounts))
-	}
-}
-
-func TestCacheAddDeleteOrder(t *testing.T) {
-	cache, _ := newAccountCache("testdata/no-such-dir")
-	cache.watcher.running = true // prevent unexpected reloads
-
-	accs := []accounts.Account{
-		{
-			Address: common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "-309830980"},
-		},
-		{
-			Address: common.HexToAddress("2cac1adea150210703ba75ed097ddfe24e14f213"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "ggg"},
-		},
-		{
-			Address: common.HexToAddress("8bda78331c916a08481428e4b07c96d3e916d165"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "zzzzzz-the-very-last-one.keyXXX"},
-		},
-		{
-			Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "SOMETHING.key"},
-		},
-		{
-			Address: common.HexToAddress("7ef5a6135f1fd6a02593eedc869c6d41d934aef8"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8"},
-		},
-		{
-			Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "aaa"},
-		},
-		{
-			Address: common.HexToAddress("289d485d9771714cce91d3393d764e1311907acc"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: "zzz"},
-		},
-	}
-	for _, a := range accs {
-		cache.add(a)
-	}
-	// Add some of them twice to check that they don't get reinserted.
-	cache.add(accs[0])
-	cache.add(accs[2])
-
-	// Check that the account list is sorted by filename.
-	wantAccounts := make([]accounts.Account, len(accs))
-	copy(wantAccounts, accs)
-	sort.Sort(accountsByURL(wantAccounts))
-	list := cache.accounts()
-	if !reflect.DeepEqual(list, wantAccounts) {
-		t.Fatalf("got accounts: %s\nwant %s", spew.Sdump(accs), spew.Sdump(wantAccounts))
-	}
-	for _, a := range accs {
-		if !cache.hasAddress(a.Address) {
-			t.Errorf("expected hasAccount(%x) to return true", a.Address)
-		}
-	}
-	if cache.hasAddress(common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e")) {
-		t.Errorf("expected hasAccount(%x) to return false", common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e"))
-	}
-
-	// Delete a few keys from the cache.
-	for i := 0; i < len(accs); i += 2 {
-		cache.delete(wantAccounts[i])
-	}
-	cache.delete(accounts.Account{Address: common.HexToAddress("fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e"), URL: accounts.URL{Scheme: KeyStoreScheme, Path: "something"}})
-
-	// Check content again after deletion.
-	wantAccountsAfterDelete := []accounts.Account{
-		wantAccounts[1],
-		wantAccounts[3],
-		wantAccounts[5],
-	}
-	list = cache.accounts()
-	if !reflect.DeepEqual(list, wantAccountsAfterDelete) {
-		t.Fatalf("got accounts after delete: %s\nwant %s", spew.Sdump(list), spew.Sdump(wantAccountsAfterDelete))
-	}
-	for _, a := range wantAccountsAfterDelete {
-		if !cache.hasAddress(a.Address) {
-			t.Errorf("expected hasAccount(%x) to return true", a.Address)
-		}
-	}
-	if cache.hasAddress(wantAccounts[0].Address) {
-		t.Errorf("expected hasAccount(%x) to return false", wantAccounts[0].Address)
-	}
-}
-
-func TestCacheFind(t *testing.T) {
-	dir := filepath.Join("testdata", "dir")
-	cache, _ := newAccountCache(dir)
-	cache.watcher.running = true // prevent unexpected reloads
-
-	accs := []accounts.Account{
-		{
-			Address: common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "a.key")},
-		},
-		{
-			Address: common.HexToAddress("2cac1adea150210703ba75ed097ddfe24e14f213"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "b.key")},
-		},
-		{
-			Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "c.key")},
-		},
-		{
-			Address: common.HexToAddress("d49ff4eeb0b2686ed89c0fc0f2b6ea533ddbbd5e"),
-			URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "c2.key")},
-		},
-	}
-	for _, a := range accs {
-		cache.add(a)
-	}
-
-	nomatchAccount := accounts.Account{
-		Address: common.HexToAddress("f466859ead1932d743d622cb74fc058882e8648a"),
-		URL:     accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Join(dir, "something")},
-	}
-	tests := []struct {
-		Query      accounts.Account
-		WantResult accounts.Account
-		WantError  error
-	}{
-		// by address
-		{Query: accounts.Account{Address: accs[0].Address}, WantResult: accs[0]},
-		// by file
-		{Query: accounts.Account{URL: accs[0].URL}, WantResult: accs[0]},
-		// by basename
-		{Query: accounts.Account{URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Base(accs[0].URL.Path)}}, WantResult: accs[0]},
-		// by file and address
-		{Query: accs[0], WantResult: accs[0]},
-		// ambiguous address, tie resolved by file
-		{Query: accs[2], WantResult: accs[2]},
-		// ambiguous address error
-		{
-			Query: accounts.Account{Address: accs[2].Address},
-			WantError: &AmbiguousAddrError{
-				Addr:    accs[2].Address,
-				Matches: []accounts.Account{accs[2], accs[3]},
-			},
-		},
-		// no match error
-		{Query: nomatchAccount, WantError: ErrNoMatch},
-		{Query: accounts.Account{URL: nomatchAccount.URL}, WantError: ErrNoMatch},
-		{Query: accounts.Account{URL: accounts.URL{Scheme: KeyStoreScheme, Path: filepath.Base(nomatchAccount.URL.Path)}}, WantError: ErrNoMatch},
-		{Query: accounts.Account{Address: nomatchAccount.Address}, WantError: ErrNoMatch},
-	}
-	for i, test := range tests {
-		a, err := cache.find(test.Query)
-		if !reflect.DeepEqual(err, test.WantError) {
-			t.Errorf("test %d: error mismatch for query %v\ngot %q\nwant %q", i, test.Query, err, test.WantError)
-			continue
-		}
-		if a != test.WantResult {
-			t.Errorf("test %d: result mismatch for query %v\ngot %v\nwant %v", i, test.Query, a, test.WantResult)
-			continue
-		}
-	}
-}
-
-func waitForAccounts(wantAccounts []accounts.Account, ks *KeyStore) error {
-	var list []accounts.Account
-	for d := 200 * time.Millisecond; d < 8*time.Second; d *= 2 {
-		list = ks.Accounts()
-		if reflect.DeepEqual(list, wantAccounts) {
-			// ks should have also received change notifications
-			select {
-			case <-ks.changes:
-			default:
-				return fmt.Errorf("wasn't notified of new accounts")
-			}
-			return nil
-		}
-		time.Sleep(d)
-	}
-	return fmt.Errorf("\ngot  %v\nwant %v", list, wantAccounts)
-}
-
-// TestUpdatedKeyfileContents tests that updating the contents of a keystore file
-// is noticed by the watcher, and the account cache is updated accordingly
-func TestUpdatedKeyfileContents(t *testing.T) {
-	t.Parallel()
-
-	// Create a temporary kesytore to test with
-	rand.Seed(time.Now().UnixNano())
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watch-test-%d-%d", os.Getpid(), rand.Int()))
-	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
-
-	list := ks.Accounts()
-	if len(list) > 0 {
-		t.Error("initial account list not empty:", list)
-	}
-	time.Sleep(100 * time.Millisecond)
-
-	// Create the directory and copy a key file into it.
-	os.MkdirAll(dir, 0700)
-	defer os.RemoveAll(dir)
-	file := filepath.Join(dir, "aaa")
-
-	// Place one of our testfiles in there
-	if err := cp.CopyFile(file, cachetestAccounts[0].URL.Path); err != nil {
-		t.Fatal(err)
-	}
-
-	// ks should see the account.
-	wantAccounts := []accounts.Account{cachetestAccounts[0]}
-	wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
-	if err := waitForAccounts(wantAccounts, ks); err != nil {
-		t.Error(err)
-		return
-	}
-
-	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	time.Sleep(1000 * time.Millisecond)
-
-	// Now replace file contents
-	if err := forceCopyFile(file, cachetestAccounts[1].URL.Path); err != nil {
-		t.Fatal(err)
-		return
-	}
-	wantAccounts = []accounts.Account{cachetestAccounts[1]}
-	wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
-	if err := waitForAccounts(wantAccounts, ks); err != nil {
-		t.Errorf("First replacement failed")
-		t.Error(err)
-		return
-	}
-
-	// needed so that modTime of `file` is different to its current value after forceCopyFile
-	time.Sleep(1000 * time.Millisecond)
-
-	// Now replace file contents again
-	if err := forceCopyFile(file, cachetestAccounts[2].URL.Path); err != nil {
-		t.Fatal(err)
-		return
-	}
-	wantAccounts = []accounts.Account{cachetestAccounts[2]}
-	wantAccounts[0].URL = accounts.URL{Scheme: KeyStoreScheme, Path: file}
-	if err := waitForAccounts(wantAccounts, ks); err != nil {
-		t.Errorf("Second replacement failed")
-		t.Error(err)
-		return
-	}
-
-	// needed so that modTime of `file` is different to its current value after ioutil.WriteFile
-	time.Sleep(1000 * time.Millisecond)
-
-	// Now replace file contents with crap
-	if err := ioutil.WriteFile(file, []byte("foo"), 0644); err != nil {
-		t.Fatal(err)
-		return
-	}
-	if err := waitForAccounts([]accounts.Account{}, ks); err != nil {
-		t.Errorf("Emptying account file failed")
-		t.Error(err)
-		return
-	}
-}
-
-// forceCopyFile is like cp.CopyFile, but doesn't complain if the destination exists.
-func forceCopyFile(dst, src string) error {
-	data, err := ioutil.ReadFile(src)
-	if err != nil {
-		return err
-	}
-	return ioutil.WriteFile(dst, data, 0644)
-}
--- a/accounts/keystore/keystore.go
+++ b/accounts/keystore/keystore.go
@ -1,495 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// Package keystore implements encrypted storage of secp256k1 private keys.
-//
-// Keys are stored as encrypted JSON files according to the Web3 Secret Storage specification.
-// See https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition for more information.
-package keystore
-
-import (
-	"crypto/ecdsa"
-	crand "crypto/rand"
-	"errors"
-	"fmt"
-	"math/big"
-	"os"
-	"path/filepath"
-	"reflect"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-var (
-	ErrLocked  = accounts.NewAuthNeededError("password or unlock")
-	ErrNoMatch = errors.New("no key for given address or file")
-	ErrDecrypt = errors.New("could not decrypt key with given password")
-)
-
-// KeyStoreType is the reflect type of a keystore backend.
-var KeyStoreType = reflect.TypeOf(&KeyStore{})
-
-// KeyStoreScheme is the protocol scheme prefixing account and wallet URLs.
-const KeyStoreScheme = "keystore"
-
-// Maximum time between wallet refreshes (if filesystem notifications don't work).
-const walletRefreshCycle = 3 * time.Second
-
-// KeyStore manages a key storage directory on disk.
-type KeyStore struct {
-	storage  keyStore                     // Storage backend, might be cleartext or encrypted
-	cache    *accountCache                // In-memory account cache over the filesystem storage
-	changes  chan struct{}                // Channel receiving change notifications from the cache
-	unlocked map[common.Address]*unlocked // Currently unlocked account (decrypted private keys)
-
-	wallets     []accounts.Wallet       // Wallet wrappers around the individual key files
-	updateFeed  event.Feed              // Event feed to notify wallet additions/removals
-	updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
-	updating    bool                    // Whether the event notification loop is running
-
-	mu sync.RWMutex
-}
-
-type unlocked struct {
-	*Key
-	abort chan struct{}
-}
-
-// NewKeyStore creates a keystore for the given directory.
-func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
-	keydir, _ = filepath.Abs(keydir)
-	ks := &KeyStore{storage: &keyStorePassphrase{keydir, scryptN, scryptP, false}}
-	ks.init(keydir)
-	return ks
-}
-
-// NewPlaintextKeyStore creates a keystore for the given directory.
-// Deprecated: Use NewKeyStore.
-func NewPlaintextKeyStore(keydir string) *KeyStore {
-	keydir, _ = filepath.Abs(keydir)
-	ks := &KeyStore{storage: &keyStorePlain{keydir}}
-	ks.init(keydir)
-	return ks
-}
-
-func (ks *KeyStore) init(keydir string) {
-	// Lock the mutex since the account cache might call back with events
-	ks.mu.Lock()
-	defer ks.mu.Unlock()
-
-	// Initialize the set of unlocked keys and the account cache
-	ks.unlocked = make(map[common.Address]*unlocked)
-	ks.cache, ks.changes = newAccountCache(keydir)
-
-	// TODO: In order for this finalizer to work, there must be no references
-	// to ks. addressCache doesn't keep a reference but unlocked keys do,
-	// so the finalizer will not trigger until all timed unlocks have expired.
-	runtime.SetFinalizer(ks, func(m *KeyStore) {
-		m.cache.close()
-	})
-	// Create the initial list of wallets from the cache
-	accs := ks.cache.accounts()
-	ks.wallets = make([]accounts.Wallet, len(accs))
-	for i := 0; i < len(accs); i++ {
-		ks.wallets[i] = &keystoreWallet{account: accs[i], keystore: ks}
-	}
-}
-
-// Wallets implements accounts.Backend, returning all single-key wallets from the
-// keystore directory.
-func (ks *KeyStore) Wallets() []accounts.Wallet {
-	// Make sure the list of wallets is in sync with the account cache
-	ks.refreshWallets()
-
-	ks.mu.RLock()
-	defer ks.mu.RUnlock()
-
-	cpy := make([]accounts.Wallet, len(ks.wallets))
-	copy(cpy, ks.wallets)
-	return cpy
-}
-
-// refreshWallets retrieves the current account list and based on that does any
-// necessary wallet refreshes.
-func (ks *KeyStore) refreshWallets() {
-	// Retrieve the current list of accounts
-	ks.mu.Lock()
-	accs := ks.cache.accounts()
-
-	// Transform the current list of wallets into the new one
-	var (
-		wallets = make([]accounts.Wallet, 0, len(accs))
-		events  []accounts.WalletEvent
-	)
-
-	for _, account := range accs {
-		// Drop wallets while they were in front of the next account
-		for len(ks.wallets) > 0 && ks.wallets[0].URL().Cmp(account.URL) < 0 {
-			events = append(events, accounts.WalletEvent{Wallet: ks.wallets[0], Kind: accounts.WalletDropped})
-			ks.wallets = ks.wallets[1:]
-		}
-		// If there are no more wallets or the account is before the next, wrap new wallet
-		if len(ks.wallets) == 0 || ks.wallets[0].URL().Cmp(account.URL) > 0 {
-			wallet := &keystoreWallet{account: account, keystore: ks}
-
-			events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
-			wallets = append(wallets, wallet)
-			continue
-		}
-		// If the account is the same as the first wallet, keep it
-		if ks.wallets[0].Accounts()[0] == account {
-			wallets = append(wallets, ks.wallets[0])
-			ks.wallets = ks.wallets[1:]
-			continue
-		}
-	}
-	// Drop any leftover wallets and set the new batch
-	for _, wallet := range ks.wallets {
-		events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
-	}
-	ks.wallets = wallets
-	ks.mu.Unlock()
-
-	// Fire all wallet events and return
-	for _, event := range events {
-		ks.updateFeed.Send(event)
-	}
-}
-
-// Subscribe implements accounts.Backend, creating an async subscription to
-// receive notifications on the addition or removal of keystore wallets.
-func (ks *KeyStore) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
-	// We need the mutex to reliably start/stop the update loop
-	ks.mu.Lock()
-	defer ks.mu.Unlock()
-
-	// Subscribe the caller and track the subscriber count
-	sub := ks.updateScope.Track(ks.updateFeed.Subscribe(sink))
-
-	// Subscribers require an active notification loop, start it
-	if !ks.updating {
-		ks.updating = true
-		go ks.updater()
-	}
-	return sub
-}
-
-// updater is responsible for maintaining an up-to-date list of wallets stored in
-// the keystore, and for firing wallet addition/removal events. It listens for
-// account change events from the underlying account cache, and also periodically
-// forces a manual refresh (only triggers for systems where the filesystem notifier
-// is not running).
-func (ks *KeyStore) updater() {
-	for {
-		// Wait for an account update or a refresh timeout
-		select {
-		case <-ks.changes:
-		case <-time.After(walletRefreshCycle):
-		}
-		// Run the wallet refresher
-		ks.refreshWallets()
-
-		// If all our subscribers left, stop the updater
-		ks.mu.Lock()
-		if ks.updateScope.Count() == 0 {
-			ks.updating = false
-			ks.mu.Unlock()
-			return
-		}
-		ks.mu.Unlock()
-	}
-}
-
-// HasAddress reports whether a key with the given address is present.
-func (ks *KeyStore) HasAddress(addr common.Address) bool {
-	return ks.cache.hasAddress(addr)
-}
-
-// Accounts returns all key files present in the directory.
-func (ks *KeyStore) Accounts() []accounts.Account {
-	return ks.cache.accounts()
-}
-
-// Delete deletes the key matched by account if the passphrase is correct.
-// If the account contains no filename, the address must match a unique key.
-func (ks *KeyStore) Delete(a accounts.Account, passphrase string) error {
-	// Decrypting the key isn't really necessary, but we do
-	// it anyway to check the password and zero out the key
-	// immediately afterwards.
-	a, key, err := ks.getDecryptedKey(a, passphrase)
-	if key != nil {
-		zeroKey(key.PrivateKey)
-	}
-	if err != nil {
-		return err
-	}
-	// The order is crucial here. The key is dropped from the
-	// cache after the file is gone so that a reload happening in
-	// between won't insert it into the cache again.
-	err = os.Remove(a.URL.Path)
-	if err == nil {
-		ks.cache.delete(a)
-		ks.refreshWallets()
-	}
-	return err
-}
-
-// SignHash calculates a ECDSA signature for the given hash. The produced
-// signature is in the [R || S || V] format where V is 0 or 1.
-func (ks *KeyStore) SignHash(a accounts.Account, hash []byte) ([]byte, error) {
-	// Look up the key to sign with and abort if it cannot be found
-	ks.mu.RLock()
-	defer ks.mu.RUnlock()
-
-	unlockedKey, found := ks.unlocked[a.Address]
-	if !found {
-		return nil, ErrLocked
-	}
-	// Sign the hash using plain ECDSA operations
-	return crypto.Sign(hash, unlockedKey.PrivateKey)
-}
-
-// SignTx signs the given transaction with the requested account.
-func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	// Look up the key to sign with and abort if it cannot be found
-	ks.mu.RLock()
-	defer ks.mu.RUnlock()
-
-	unlockedKey, found := ks.unlocked[a.Address]
-	if !found {
-		return nil, ErrLocked
-	}
-	// Depending on the presence of the chain ID, sign with EIP155 or homestead
-	if chainID != nil {
-		return types.SignTx(tx, types.NewEIP155Signer(chainID), unlockedKey.PrivateKey)
-	}
-	return types.SignTx(tx, types.HomesteadSigner{}, unlockedKey.PrivateKey)
-}
-
-// SignHashWithPassphrase signs hash if the private key matching the given address
-// can be decrypted with the given passphrase. The produced signature is in the
-// [R || S || V] format where V is 0 or 1.
-func (ks *KeyStore) SignHashWithPassphrase(a accounts.Account, passphrase string, hash []byte) (signature []byte, err error) {
-	_, key, err := ks.getDecryptedKey(a, passphrase)
-	if err != nil {
-		return nil, err
-	}
-	defer zeroKey(key.PrivateKey)
-	return crypto.Sign(hash, key.PrivateKey)
-}
-
-// SignTxWithPassphrase signs the transaction if the private key matching the
-// given address can be decrypted with the given passphrase.
-func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	_, key, err := ks.getDecryptedKey(a, passphrase)
-	if err != nil {
-		return nil, err
-	}
-	defer zeroKey(key.PrivateKey)
-
-	// Depending on the presence of the chain ID, sign with EIP155 or homestead
-	if chainID != nil {
-		return types.SignTx(tx, types.NewEIP155Signer(chainID), key.PrivateKey)
-	}
-	return types.SignTx(tx, types.HomesteadSigner{}, key.PrivateKey)
-}
-
-// Unlock unlocks the given account indefinitely.
-func (ks *KeyStore) Unlock(a accounts.Account, passphrase string) error {
-	return ks.TimedUnlock(a, passphrase, 0)
-}
-
-// Lock removes the private key with the given address from memory.
-func (ks *KeyStore) Lock(addr common.Address) error {
-	ks.mu.Lock()
-	if unl, found := ks.unlocked[addr]; found {
-		ks.mu.Unlock()
-		ks.expire(addr, unl, time.Duration(0)*time.Nanosecond)
-	} else {
-		ks.mu.Unlock()
-	}
-	return nil
-}
-
-// TimedUnlock unlocks the given account with the passphrase. The account
-// stays unlocked for the duration of timeout. A timeout of 0 unlocks the account
-// until the program exits. The account must match a unique key file.
-//
-// If the account address is already unlocked for a duration, TimedUnlock extends or
-// shortens the active unlock timeout. If the address was previously unlocked
-// indefinitely the timeout is not altered.
-func (ks *KeyStore) TimedUnlock(a accounts.Account, passphrase string, timeout time.Duration) error {
-	a, key, err := ks.getDecryptedKey(a, passphrase)
-	if err != nil {
-		return err
-	}
-
-	ks.mu.Lock()
-	defer ks.mu.Unlock()
-	u, found := ks.unlocked[a.Address]
-	if found {
-		if u.abort == nil {
-			// The address was unlocked indefinitely, so unlocking
-			// it with a timeout would be confusing.
-			zeroKey(key.PrivateKey)
-			return nil
-		}
-		// Terminate the expire goroutine and replace it below.
-		close(u.abort)
-	}
-	if timeout > 0 {
-		u = &unlocked{Key: key, abort: make(chan struct{})}
-		go ks.expire(a.Address, u, timeout)
-	} else {
-		u = &unlocked{Key: key}
-	}
-	ks.unlocked[a.Address] = u
-	return nil
-}
-
-// Find resolves the given account into a unique entry in the keystore.
-func (ks *KeyStore) Find(a accounts.Account) (accounts.Account, error) {
-	ks.cache.maybeReload()
-	ks.cache.mu.Lock()
-	a, err := ks.cache.find(a)
-	ks.cache.mu.Unlock()
-	return a, err
-}
-
-func (ks *KeyStore) getDecryptedKey(a accounts.Account, auth string) (accounts.Account, *Key, error) {
-	a, err := ks.Find(a)
-	if err != nil {
-		return a, nil, err
-	}
-	key, err := ks.storage.GetKey(a.Address, a.URL.Path, auth)
-	return a, key, err
-}
-
-func (ks *KeyStore) expire(addr common.Address, u *unlocked, timeout time.Duration) {
-	t := time.NewTimer(timeout)
-	defer t.Stop()
-	select {
-	case <-u.abort:
-		// just quit
-	case <-t.C:
-		ks.mu.Lock()
-		// only drop if it's still the same key instance that dropLater
-		// was launched with. we can check that using pointer equality
-		// because the map stores a new pointer every time the key is
-		// unlocked.
-		if ks.unlocked[addr] == u {
-			zeroKey(u.PrivateKey)
-			delete(ks.unlocked, addr)
-		}
-		ks.mu.Unlock()
-	}
-}
-
-// NewAccount generates a new key and stores it into the key directory,
-// encrypting it with the passphrase.
-func (ks *KeyStore) NewAccount(passphrase string) (accounts.Account, error) {
-	_, account, err := storeNewKey(ks.storage, crand.Reader, passphrase)
-	if err != nil {
-		return accounts.Account{}, err
-	}
-	// Add the account to the cache immediately rather
-	// than waiting for file system notifications to pick it up.
-	ks.cache.add(account)
-	ks.refreshWallets()
-	return account, nil
-}
-
-// Export exports as a JSON key, encrypted with newPassphrase.
-func (ks *KeyStore) Export(a accounts.Account, passphrase, newPassphrase string) (keyJSON []byte, err error) {
-	_, key, err := ks.getDecryptedKey(a, passphrase)
-	if err != nil {
-		return nil, err
-	}
-	var N, P int
-	if store, ok := ks.storage.(*keyStorePassphrase); ok {
-		N, P = store.scryptN, store.scryptP
-	} else {
-		N, P = StandardScryptN, StandardScryptP
-	}
-	return EncryptKey(key, newPassphrase, N, P)
-}
-
-// Import stores the given encrypted JSON key into the key directory.
-func (ks *KeyStore) Import(keyJSON []byte, passphrase, newPassphrase string) (accounts.Account, error) {
-	key, err := DecryptKey(keyJSON, passphrase)
-	if key != nil && key.PrivateKey != nil {
-		defer zeroKey(key.PrivateKey)
-	}
-	if err != nil {
-		return accounts.Account{}, err
-	}
-	return ks.importKey(key, newPassphrase)
-}
-
-// ImportECDSA stores the given key into the key directory, encrypting it with the passphrase.
-func (ks *KeyStore) ImportECDSA(priv *ecdsa.PrivateKey, passphrase string) (accounts.Account, error) {
-	key := newKeyFromECDSA(priv)
-	if ks.cache.hasAddress(key.Address) {
-		return accounts.Account{}, fmt.Errorf("account already exists")
-	}
-	return ks.importKey(key, passphrase)
-}
-
-func (ks *KeyStore) importKey(key *Key, passphrase string) (accounts.Account, error) {
-	a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.storage.JoinPath(keyFileName(key.Address))}}
-	if err := ks.storage.StoreKey(a.URL.Path, key, passphrase); err != nil {
-		return accounts.Account{}, err
-	}
-	ks.cache.add(a)
-	ks.refreshWallets()
-	return a, nil
-}
-
-// Update changes the passphrase of an existing account.
-func (ks *KeyStore) Update(a accounts.Account, passphrase, newPassphrase string) error {
-	a, key, err := ks.getDecryptedKey(a, passphrase)
-	if err != nil {
-		return err
-	}
-	return ks.storage.StoreKey(a.URL.Path, key, newPassphrase)
-}
-
-// ImportPreSaleKey decrypts the given Ethereum presale wallet and stores
-// a key file in the key directory. The key file is encrypted with the same passphrase.
-func (ks *KeyStore) ImportPreSaleKey(keyJSON []byte, passphrase string) (accounts.Account, error) {
-	a, _, err := importPreSaleKey(ks.storage, keyJSON, passphrase)
-	if err != nil {
-		return a, err
-	}
-	ks.cache.add(a)
-	ks.refreshWallets()
-	return a, nil
-}
-
-// zeroKey zeroes a private key in memory.
-func zeroKey(k *ecdsa.PrivateKey) {
-	b := k.D.Bits()
-	for i := range b {
-		b[i] = 0
-	}
-}
--- a/accounts/keystore/keystore_test.go
+++ b/accounts/keystore/keystore_test.go
@ -1,387 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package keystore
-
-import (
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"runtime"
-	"sort"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-var testSigData = make([]byte, 32)
-
-func TestKeyStore(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-
-	a, err := ks.NewAccount("foo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.HasPrefix(a.URL.Path, dir) {
-		t.Errorf("account file %s doesn't have dir prefix", a.URL)
-	}
-	stat, err := os.Stat(a.URL.Path)
-	if err != nil {
-		t.Fatalf("account file %s doesn't exist (%v)", a.URL, err)
-	}
-	if runtime.GOOS != "windows" && stat.Mode() != 0600 {
-		t.Fatalf("account file has wrong mode: got %o, want %o", stat.Mode(), 0600)
-	}
-	if !ks.HasAddress(a.Address) {
-		t.Errorf("HasAccount(%x) should've returned true", a.Address)
-	}
-	if err := ks.Update(a, "foo", "bar"); err != nil {
-		t.Errorf("Update error: %v", err)
-	}
-	if err := ks.Delete(a, "bar"); err != nil {
-		t.Errorf("Delete error: %v", err)
-	}
-	if common.FileExist(a.URL.Path) {
-		t.Errorf("account file %s should be gone after Delete", a.URL)
-	}
-	if ks.HasAddress(a.Address) {
-		t.Errorf("HasAccount(%x) should've returned true after Delete", a.Address)
-	}
-}
-
-func TestSign(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-
-	pass := "" // not used but required by API
-	a1, err := ks.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := ks.Unlock(a1, ""); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestSignWithPassphrase(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-
-	pass := "passwd"
-	acc, err := ks.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if _, unlocked := ks.unlocked[acc.Address]; unlocked {
-		t.Fatal("expected account to be locked")
-	}
-
-	_, err = ks.SignHashWithPassphrase(acc, pass, testSigData)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if _, unlocked := ks.unlocked[acc.Address]; unlocked {
-		t.Fatal("expected account to be locked")
-	}
-
-	if _, err = ks.SignHashWithPassphrase(acc, "invalid passwd", testSigData); err == nil {
-		t.Fatal("expected SignHashWithPassphrase to fail with invalid password")
-	}
-}
-
-func TestTimedUnlock(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-
-	pass := "foo"
-	a1, err := ks.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Signing without passphrase fails because account is locked
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != ErrLocked {
-		t.Fatal("Signing should've failed with ErrLocked before unlocking, got ", err)
-	}
-
-	// Signing with passphrase works
-	if err = ks.TimedUnlock(a1, pass, 100*time.Millisecond); err != nil {
-		t.Fatal(err)
-	}
-
-	// Signing without passphrase works because account is temp unlocked
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != nil {
-		t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
-	}
-
-	// Signing fails again after automatic locking
-	time.Sleep(250 * time.Millisecond)
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != ErrLocked {
-		t.Fatal("Signing should've failed with ErrLocked timeout expired, got ", err)
-	}
-}
-
-func TestOverrideUnlock(t *testing.T) {
-	dir, ks := tmpKeyStore(t, false)
-	defer os.RemoveAll(dir)
-
-	pass := "foo"
-	a1, err := ks.NewAccount(pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// Unlock indefinitely.
-	if err = ks.TimedUnlock(a1, pass, 5*time.Minute); err != nil {
-		t.Fatal(err)
-	}
-
-	// Signing without passphrase works because account is temp unlocked
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != nil {
-		t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
-	}
-
-	// reset unlock to a shorter period, invalidates the previous unlock
-	if err = ks.TimedUnlock(a1, pass, 100*time.Millisecond); err != nil {
-		t.Fatal(err)
-	}
-
-	// Signing without passphrase still works because account is temp unlocked
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != nil {
-		t.Fatal("Signing shouldn't return an error after unlocking, got ", err)
-	}
-
-	// Signing fails again after automatic locking
-	time.Sleep(250 * time.Millisecond)
-	_, err = ks.SignHash(accounts.Account{Address: a1.Address}, testSigData)
-	if err != ErrLocked {
-		t.Fatal("Signing should've failed with ErrLocked timeout expired, got ", err)
-	}
-}
-
-// This test should fail under -race if signing races the expiration goroutine.
-func TestSignRace(t *testing.T) {
-	dir, ks := tmpKeyStore(t, false)
-	defer os.RemoveAll(dir)
-
-	// Create a test account.
-	a1, err := ks.NewAccount("")
-	if err != nil {
-		t.Fatal("could not create the test account", err)
-	}
-
-	if err := ks.TimedUnlock(a1, "", 15*time.Millisecond); err != nil {
-		t.Fatal("could not unlock the test account", err)
-	}
-	end := time.Now().Add(500 * time.Millisecond)
-	for time.Now().Before(end) {
-		if _, err := ks.SignHash(accounts.Account{Address: a1.Address}, testSigData); err == ErrLocked {
-			return
-		} else if err != nil {
-			t.Errorf("Sign error: %v", err)
-			return
-		}
-		time.Sleep(1 * time.Millisecond)
-	}
-	t.Errorf("Account did not lock within the timeout")
-}
-
-// Tests that the wallet notifier loop starts and stops correctly based on the
-// addition and removal of wallet event subscriptions.
-func TestWalletNotifierLifecycle(t *testing.T) {
-	// Create a temporary kesytore to test with
-	dir, ks := tmpKeyStore(t, false)
-	defer os.RemoveAll(dir)
-
-	// Ensure that the notification updater is not running yet
-	time.Sleep(250 * time.Millisecond)
-	ks.mu.RLock()
-	updating := ks.updating
-	ks.mu.RUnlock()
-
-	if updating {
-		t.Errorf("wallet notifier running without subscribers")
-	}
-	// Subscribe to the wallet feed and ensure the updater boots up
-	updates := make(chan accounts.WalletEvent)
-
-	subs := make([]event.Subscription, 2)
-	for i := 0; i < len(subs); i++ {
-		// Create a new subscription
-		subs[i] = ks.Subscribe(updates)
-
-		// Ensure the notifier comes online
-		time.Sleep(250 * time.Millisecond)
-		ks.mu.RLock()
-		updating = ks.updating
-		ks.mu.RUnlock()
-
-		if !updating {
-			t.Errorf("sub %d: wallet notifier not running after subscription", i)
-		}
-	}
-	// Unsubscribe and ensure the updater terminates eventually
-	for i := 0; i < len(subs); i++ {
-		// Close an existing subscription
-		subs[i].Unsubscribe()
-
-		// Ensure the notifier shuts down at and only at the last close
-		for k := 0; k < int(walletRefreshCycle/(250*time.Millisecond))+2; k++ {
-			ks.mu.RLock()
-			updating = ks.updating
-			ks.mu.RUnlock()
-
-			if i < len(subs)-1 && !updating {
-				t.Fatalf("sub %d: event notifier stopped prematurely", i)
-			}
-			if i == len(subs)-1 && !updating {
-				return
-			}
-			time.Sleep(250 * time.Millisecond)
-		}
-	}
-	t.Errorf("wallet notifier didn't terminate after unsubscribe")
-}
-
-type walletEvent struct {
-	accounts.WalletEvent
-	a accounts.Account
-}
-
-// Tests that wallet notifications and correctly fired when accounts are added
-// or deleted from the keystore.
-func TestWalletNotifications(t *testing.T) {
-	dir, ks := tmpKeyStore(t, false)
-	defer os.RemoveAll(dir)
-
-	// Subscribe to the wallet feed and collect events.
-	var (
-		events  []walletEvent
-		updates = make(chan accounts.WalletEvent)
-		sub     = ks.Subscribe(updates)
-	)
-	defer sub.Unsubscribe()
-	go func() {
-		for {
-			select {
-			case ev := <-updates:
-				events = append(events, walletEvent{ev, ev.Wallet.Accounts()[0]})
-			case <-sub.Err():
-				close(updates)
-				return
-			}
-		}
-	}()
-
-	// Randomly add and remove accounts.
-	var (
-		live       = make(map[common.Address]accounts.Account)
-		wantEvents []walletEvent
-	)
-	for i := 0; i < 1024; i++ {
-		if create := len(live) == 0 || rand.Int()%4 > 0; create {
-			// Add a new account and ensure wallet notifications arrives
-			account, err := ks.NewAccount("")
-			if err != nil {
-				t.Fatalf("failed to create test account: %v", err)
-			}
-			live[account.Address] = account
-			wantEvents = append(wantEvents, walletEvent{accounts.WalletEvent{Kind: accounts.WalletArrived}, account})
-		} else {
-			// Delete a random account.
-			var account accounts.Account
-			for _, a := range live {
-				account = a
-				break
-			}
-			if err := ks.Delete(account, ""); err != nil {
-				t.Fatalf("failed to delete test account: %v", err)
-			}
-			delete(live, account.Address)
-			wantEvents = append(wantEvents, walletEvent{accounts.WalletEvent{Kind: accounts.WalletDropped}, account})
-		}
-	}
-
-	// Shut down the event collector and check events.
-	sub.Unsubscribe()
-	<-updates
-	checkAccounts(t, live, ks.Wallets())
-	checkEvents(t, wantEvents, events)
-}
-
-// checkAccounts checks that all known live accounts are present in the wallet list.
-func checkAccounts(t *testing.T, live map[common.Address]accounts.Account, wallets []accounts.Wallet) {
-	if len(live) != len(wallets) {
-		t.Errorf("wallet list doesn't match required accounts: have %d, want %d", len(wallets), len(live))
-		return
-	}
-	liveList := make([]accounts.Account, 0, len(live))
-	for _, account := range live {
-		liveList = append(liveList, account)
-	}
-	sort.Sort(accountsByURL(liveList))
-	for j, wallet := range wallets {
-		if accs := wallet.Accounts(); len(accs) != 1 {
-			t.Errorf("wallet %d: contains invalid number of accounts: have %d, want 1", j, len(accs))
-		} else if accs[0] != liveList[j] {
-			t.Errorf("wallet %d: account mismatch: have %v, want %v", j, accs[0], liveList[j])
-		}
-	}
-}
-
-// checkEvents checks that all events in 'want' are present in 'have'. Events may be present multiple times.
-func checkEvents(t *testing.T, want []walletEvent, have []walletEvent) {
-	for _, wantEv := range want {
-		nmatch := 0
-		for ; len(have) > 0; nmatch++ {
-			if have[0].Kind != wantEv.Kind || have[0].a != wantEv.a {
-				break
-			}
-			have = have[1:]
-		}
-		if nmatch == 0 {
-			t.Fatalf("can't find event with Kind=%v for %x", wantEv.Kind, wantEv.a.Address)
-		}
-	}
-}
-
-func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
-	d, err := ioutil.TempDir("", "eth-keystore-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	newKs := NewPlaintextKeyStore
-	if encrypted {
-		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
-	}
-	return d, newKs(d)
-}
--- a/accounts/keystore/passphrase_test.go
+++ b/accounts/keystore/passphrase_test.go
@ -1,60 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package keystore
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-const (
-	veryLightScryptN = 2
-	veryLightScryptP = 1
-)
-
-// Tests that a json key file can be decrypted and encrypted in multiple rounds.
-func TestKeyEncryptDecrypt(t *testing.T) {
-	keyjson, err := ioutil.ReadFile("testdata/very-light-scrypt.json")
-	if err != nil {
-		t.Fatal(err)
-	}
-	password := ""
-	address := common.HexToAddress("45dea0fb0bba44f4fcf290bba71fd57d7117cbb8")
-
-	// Do a few rounds of decryption and encryption
-	for i := 0; i < 3; i++ {
-		// Try a bad password first
-		if _, err := DecryptKey(keyjson, password+"bad"); err == nil {
-			t.Errorf("test %d: json key decrypted with bad password", i)
-		}
-		// Decrypt with the correct password
-		key, err := DecryptKey(keyjson, password)
-		if err != nil {
-			t.Fatalf("test %d: json key failed to decrypt: %v", i, err)
-		}
-		if key.Address != address {
-			t.Errorf("test %d: key address mismatch: have %x, want %x", i, key.Address, address)
-		}
-		// Recrypt with a new password and start over
-		password += "new data appended"
-		if keyjson, err = EncryptKey(key, password, veryLightScryptN, veryLightScryptP); err != nil {
-			t.Errorf("test %d: failed to recrypt key %v", i, err)
-		}
-	}
-}
--- a/accounts/keystore/plain_test.go
+++ b/accounts/keystore/plain_test.go
@ -1,266 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package keystore
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
-	d, err := ioutil.TempDir("", "geth-keystore-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if encrypted {
-		ks = &keyStorePassphrase{d, veryLightScryptN, veryLightScryptP, true}
-	} else {
-		ks = &keyStorePlain{d}
-	}
-	return d, ks
-}
-
-func TestKeyStorePlain(t *testing.T) {
-	dir, ks := tmpKeyStoreIface(t, false)
-	defer os.RemoveAll(dir)
-
-	pass := "" // not used but required by API
-	k1, account, err := storeNewKey(ks, rand.Reader, pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	k2, err := ks.GetKey(k1.Address, account.URL.Path, pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(k1.Address, k2.Address) {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
-		t.Fatal(err)
-	}
-}
-
-func TestKeyStorePassphrase(t *testing.T) {
-	dir, ks := tmpKeyStoreIface(t, true)
-	defer os.RemoveAll(dir)
-
-	pass := "foo"
-	k1, account, err := storeNewKey(ks, rand.Reader, pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	k2, err := ks.GetKey(k1.Address, account.URL.Path, pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(k1.Address, k2.Address) {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(k1.PrivateKey, k2.PrivateKey) {
-		t.Fatal(err)
-	}
-}
-
-func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
-	dir, ks := tmpKeyStoreIface(t, true)
-	defer os.RemoveAll(dir)
-
-	pass := "foo"
-	k1, account, err := storeNewKey(ks, rand.Reader, pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err = ks.GetKey(k1.Address, account.URL.Path, "bar"); err != ErrDecrypt {
-		t.Fatalf("wrong error for invalid password\ngot %q\nwant %q", err, ErrDecrypt)
-	}
-}
-
-func TestImportPreSaleKey(t *testing.T) {
-	dir, ks := tmpKeyStoreIface(t, true)
-	defer os.RemoveAll(dir)
-
-	// file content of a presale key file generated with:
-	// python pyethsaletool.py genwallet
-	// with password "foo"
-	fileContent := "{\"encseed\": \"26d87f5f2bf9835f9a47eefae571bc09f9107bb13d54ff12a4ec095d01f83897494cf34f7bed2ed34126ecba9db7b62de56c9d7cd136520a0427bfb11b8954ba7ac39b90d4650d3448e31185affcd74226a68f1e94b1108e6e0a4a91cdd83eba\", \"ethaddr\": \"d4584b5f6229b7be90727b0fc8c6b91bb427821f\", \"email\": \"gustav.simonsson@gmail.com\", \"btcaddr\": \"1EVknXyFC68kKNLkh6YnKzW41svSRoaAcx\"}"
-	pass := "foo"
-	account, _, err := importPreSaleKey(ks, []byte(fileContent), pass)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if account.Address != common.HexToAddress("d4584b5f6229b7be90727b0fc8c6b91bb427821f") {
-		t.Errorf("imported account has wrong address %x", account.Address)
-	}
-	if !strings.HasPrefix(account.URL.Path, dir) {
-		t.Errorf("imported account file not in keystore directory: %q", account.URL)
-	}
-}
-
-// Test and utils for the key store tests in the Ethereum JSON tests;
-// testdataKeyStoreTests/basic_tests.json
-type KeyStoreTestV3 struct {
-	Json     encryptedKeyJSONV3
-	Password string
-	Priv     string
-}
-
-type KeyStoreTestV1 struct {
-	Json     encryptedKeyJSONV1
-	Password string
-	Priv     string
-}
-
-func TestV3_PBKDF2_1(t *testing.T) {
-	t.Parallel()
-	tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
-	testDecryptV3(tests["wikipage_test_vector_pbkdf2"], t)
-}
-
-var testsSubmodule = filepath.Join("..", "..", "tests", "testdata", "KeyStoreTests")
-
-func skipIfSubmoduleMissing(t *testing.T) {
-	if !common.FileExist(testsSubmodule) {
-		t.Skipf("can't find JSON tests from submodule at %s", testsSubmodule)
-	}
-}
-
-func TestV3_PBKDF2_2(t *testing.T) {
-	skipIfSubmoduleMissing(t)
-	t.Parallel()
-	tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
-	testDecryptV3(tests["test1"], t)
-}
-
-func TestV3_PBKDF2_3(t *testing.T) {
-	skipIfSubmoduleMissing(t)
-	t.Parallel()
-	tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
-	testDecryptV3(tests["python_generated_test_with_odd_iv"], t)
-}
-
-func TestV3_PBKDF2_4(t *testing.T) {
-	skipIfSubmoduleMissing(t)
-	t.Parallel()
-	tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
-	testDecryptV3(tests["evilnonce"], t)
-}
-
-func TestV3_Scrypt_1(t *testing.T) {
-	t.Parallel()
-	tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
-	testDecryptV3(tests["wikipage_test_vector_scrypt"], t)
-}
-
-func TestV3_Scrypt_2(t *testing.T) {
-	skipIfSubmoduleMissing(t)
-	t.Parallel()
-	tests := loadKeyStoreTestV3(filepath.Join(testsSubmodule, "basic_tests.json"), t)
-	testDecryptV3(tests["test2"], t)
-}
-
-func TestV1_1(t *testing.T) {
-	t.Parallel()
-	tests := loadKeyStoreTestV1("testdata/v1_test_vector.json", t)
-	testDecryptV1(tests["test1"], t)
-}
-
-func TestV1_2(t *testing.T) {
-	t.Parallel()
-	ks := &keyStorePassphrase{"testdata/v1", LightScryptN, LightScryptP, true}
-	addr := common.HexToAddress("cb61d5a9c4896fb9658090b597ef0e7be6f7b67e")
-	file := "testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e"
-	k, err := ks.GetKey(addr, file, "g")
-	if err != nil {
-		t.Fatal(err)
-	}
-	privHex := hex.EncodeToString(crypto.FromECDSA(k.PrivateKey))
-	expectedHex := "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d"
-	if privHex != expectedHex {
-		t.Fatal(fmt.Errorf("Unexpected privkey: %v, expected %v", privHex, expectedHex))
-	}
-}
-
-func testDecryptV3(test KeyStoreTestV3, t *testing.T) {
-	privBytes, _, err := decryptKeyV3(&test.Json, test.Password)
-	if err != nil {
-		t.Fatal(err)
-	}
-	privHex := hex.EncodeToString(privBytes)
-	if test.Priv != privHex {
-		t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex))
-	}
-}
-
-func testDecryptV1(test KeyStoreTestV1, t *testing.T) {
-	privBytes, _, err := decryptKeyV1(&test.Json, test.Password)
-	if err != nil {
-		t.Fatal(err)
-	}
-	privHex := hex.EncodeToString(privBytes)
-	if test.Priv != privHex {
-		t.Fatal(fmt.Errorf("Decrypted bytes not equal to test, expected %v have %v", test.Priv, privHex))
-	}
-}
-
-func loadKeyStoreTestV3(file string, t *testing.T) map[string]KeyStoreTestV3 {
-	tests := make(map[string]KeyStoreTestV3)
-	err := common.LoadJSON(file, &tests)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return tests
-}
-
-func loadKeyStoreTestV1(file string, t *testing.T) map[string]KeyStoreTestV1 {
-	tests := make(map[string]KeyStoreTestV1)
-	err := common.LoadJSON(file, &tests)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return tests
-}
-
-func TestKeyForDirectICAP(t *testing.T) {
-	t.Parallel()
-	key := NewKeyForDirectICAP(rand.Reader)
-	if !strings.HasPrefix(key.Address.Hex(), "0x00") {
-		t.Errorf("Expected first address byte to be zero, have: %s", key.Address.Hex())
-	}
-}
-
-func TestV3_31_Byte_Key(t *testing.T) {
-	t.Parallel()
-	tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
-	testDecryptV3(tests["31_byte_key"], t)
-}
-
-func TestV3_30_Byte_Key(t *testing.T) {
-	t.Parallel()
-	tests := loadKeyStoreTestV3("testdata/v3_test_vector.json", t)
-	testDecryptV3(tests["30_byte_key"], t)
-}
--- a/accounts/keystore/testdata/dupes/1
+++ b/accounts/keystore/testdata/dupes/1
@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/dupes/2
+++ b/accounts/keystore/testdata/dupes/2
@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/dupes/foo
+++ b/accounts/keystore/testdata/dupes/foo
@ -1 +0,0 @@
-{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}
--- a/accounts/keystore/testdata/keystore/.hiddenfile
+++ b/accounts/keystore/testdata/keystore/.hiddenfile
@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/keystore/README
+++ b/accounts/keystore/testdata/keystore/README
@ -1,21 +0,0 @@
-This directory contains accounts for testing.
-The password that unlocks them is "foobar".
-
-The "good" key files which are supposed to be loadable are:
-
- File: UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
-  Address: 0x7ef5a6135f1fd6a02593eedc869c6d41d934aef8
- File: aaa
-  Address: 0xf466859ead1932d743d622cb74fc058882e8648a
- File: zzz
-  Address: 0x289d485d9771714cce91d3393d764e1311907acc
-
-The other files (including this README) are broken in various ways
-and should not be picked up by package accounts:
-
- File: no-address (missing address field, otherwise same as "aaa")
- File: garbage (file with random data)
- File: empty (file with no content)
- File: swapfile~ (should be skipped)
- File: .hiddenfile (should be skipped)
- File: foo/... (should be skipped because it is a directory)
--- a/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
+++ b/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8
@ -1 +0,0 @@
-{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}
--- a/accounts/keystore/testdata/keystore/aaa
+++ b/accounts/keystore/testdata/keystore/aaa
@ -1 +0,0 @@
-{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e
+++ b/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e
@ -1 +0,0 @@
-{"address":"fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e","crypto":{"cipher":"aes-128-ctr","ciphertext":"8124d5134aa4a927c79fd852989e4b5419397566f04b0936a1eb1d168c7c68a5","cipherparams":{"iv":"e2febe17176414dd2cda28287947eb2f"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":4096,"p":6,"r":8,"salt":"44b415ede89f3bdd6830390a21b78965f571b347a589d1d943029f016c5e8bd5"},"mac":"5e149ff25bfd9dd45746a84bb2bcd2f015f2cbca2b6d25c5de8c29617f71fe5b"},"id":"d6ac5452-2b2c-4d3c-ad80-4bf0327d971c","version":3}
--- a/accounts/keystore/testdata/keystore/garbage
+++ b/accounts/keystore/testdata/keystore/garbage
--- a/accounts/keystore/testdata/keystore/no-address
+++ b/accounts/keystore/testdata/keystore/no-address
@ -1 +0,0 @@
-{"crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/keystore/zero
+++ b/accounts/keystore/testdata/keystore/zero
@ -1 +0,0 @@
-{"address":"0000000000000000000000000000000000000000","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}
--- a/accounts/keystore/testdata/keystore/zzz
+++ b/accounts/keystore/testdata/keystore/zzz
@ -1 +0,0 @@
-{"address":"289d485d9771714cce91d3393d764e1311907acc","crypto":{"cipher":"aes-128-ctr","ciphertext":"faf32ca89d286b107f5e6d842802e05263c49b78d46eac74e6109e9a963378ab","cipherparams":{"iv":"558833eec4a665a8c55608d7d503407d"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"d571fff447ffb24314f9513f5160246f09997b857ac71348b73e785aab40dc04"},"mac":"21edb85ff7d0dab1767b9bf498f2c3cb7be7609490756bd32300bb213b59effe"},"id":"3279afcf-55ba-43ff-8997-02dcc46a6525","version":3}
--- a/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e
+++ b/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e
@ -1 +0,0 @@
-{"address":"cb61d5a9c4896fb9658090b597ef0e7be6f7b67e","Crypto":{"cipher":"aes-128-cbc","ciphertext":"6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0","cipherparams":{"iv":"35337770fc2117994ecdcad026bccff4"},"kdf":"scrypt","kdfparams":{"n":262144,"r":8,"p":1,"dklen":32,"salt":"9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"},"mac":"3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644","version":"1"},"id":"e25f7c1f-d318-4f29-b62c-687190d4d299","version":"1"}
--- a/accounts/keystore/testdata/v1_test_vector.json
+++ b/accounts/keystore/testdata/v1_test_vector.json
@ -1,28 +0,0 @@
-{
-    "test1": {
-        "json": {
-            "Crypto": {
-                "cipher": "aes-128-cbc",
-                "cipherparams": {
-                    "iv": "35337770fc2117994ecdcad026bccff4"
-                },
-                "ciphertext": "6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0",
-                "kdf": "scrypt",
-                "kdfparams": {
-                    "dklen": 32,
-                    "n": 262144,
-                    "p": 1,
-                    "r": 8,
-                    "salt": "9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"
-                },
-                "mac": "3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644",
-                "version": "1"
-            },
-            "address": "cb61d5a9c4896fb9658090b597ef0e7be6f7b67e",
-            "id": "e25f7c1f-d318-4f29-b62c-687190d4d299",
-            "version": "1"
-        },
-        "password": "g",
-        "priv": "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d"
-    }
-}
--- a/accounts/keystore/testdata/v3_test_vector.json
+++ b/accounts/keystore/testdata/v3_test_vector.json
@ -1,97 +0,0 @@
-{
-    "wikipage_test_vector_scrypt": {
-        "json": {
-            "crypto" : {
-                "cipher" : "aes-128-ctr",
-                "cipherparams" : {
-                    "iv" : "83dbcc02d8ccb40e466191a123791e0e"
-                },
-                "ciphertext" : "d172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c",
-                "kdf" : "scrypt",
-                "kdfparams" : {
-                    "dklen" : 32,
-                    "n" : 262144,
-                    "r" : 1,
-                    "p" : 8,
-                    "salt" : "ab0c7876052600dd703518d6fc3fe8984592145b591fc8fb5c6d43190334ba19"
-                },
-                "mac" : "2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097"
-            },
-            "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6",
-            "version" : 3
-        },
-        "password": "testpassword",
-        "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d"
-    },
-    "wikipage_test_vector_pbkdf2": {
-        "json": {
-            "crypto" : {
-                "cipher" : "aes-128-ctr",
-                "cipherparams" : {
-                    "iv" : "6087dab2f9fdbbfaddc31a909735c1e6"
-                },
-                "ciphertext" : "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46",
-                "kdf" : "pbkdf2",
-                "kdfparams" : {
-                    "c" : 262144,
-                    "dklen" : 32,
-                    "prf" : "hmac-sha256",
-                    "salt" : "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd"
-                },
-                "mac" : "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2"
-            },
-            "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6",
-            "version" : 3
-        },
-        "password": "testpassword",
-        "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d"
-    },
-    "31_byte_key": {
-        "json": {
-            "crypto" : {
-                "cipher" : "aes-128-ctr",
-                "cipherparams" : {
-                    "iv" : "e0c41130a323adc1446fc82f724bca2f"
-                },
-                "ciphertext" : "9517cd5bdbe69076f9bf5057248c6c050141e970efa36ce53692d5d59a3984",
-                "kdf" : "scrypt",
-                "kdfparams" : {
-                    "dklen" : 32,
-                    "n" : 2,
-                    "r" : 8,
-                    "p" : 1,
-                    "salt" : "711f816911c92d649fb4c84b047915679933555030b3552c1212609b38208c63"
-                },
-                "mac" : "d5e116151c6aa71470e67a7d42c9620c75c4d23229847dcc127794f0732b0db5"
-            },
-            "id" : "fecfc4ce-e956-48fd-953b-30f8b52ed66c",
-            "version" : 3
-        },
-        "password": "foo",
-        "priv": "fa7b3db73dc7dfdf8c5fbdb796d741e4488628c41fc4febd9160a866ba0f35"
-    },
-    "30_byte_key": {
-        "json": {
-            "crypto" : {
-                "cipher" : "aes-128-ctr",
-                "cipherparams" : {
-                    "iv" : "3ca92af36ad7c2cd92454c59cea5ef00"
-                },
-                "ciphertext" : "108b7d34f3442fc26ab1ab90ca91476ba6bfa8c00975a49ef9051dc675aa",
-                "kdf" : "scrypt",
-                "kdfparams" : {
-                    "dklen" : 32,
-                    "n" : 2,
-                    "r" : 8,
-                    "p" : 1,
-                    "salt" : "d0769e608fb86cda848065642a9c6fa046845c928175662b8e356c77f914cd3b"
-                },
-                "mac" : "75d0e6759f7b3cefa319c3be41680ab6beea7d8328653474bd06706d4cc67420"
-            },
-            "id" : "a37e1559-5955-450d-8075-7b8931b392b2",
-            "version" : 3
-        },
-        "password": "foo",
-        "priv": "81c29e8142bb6a81bef5a92bda7a8328a5c85bb2f9542e76f9b0f94fc018"
-    }
-}
--- a/accounts/keystore/testdata/very-light-scrypt.json
+++ b/accounts/keystore/testdata/very-light-scrypt.json
@ -1 +0,0 @@
-{"address":"45dea0fb0bba44f4fcf290bba71fd57d7117cbb8","crypto":{"cipher":"aes-128-ctr","ciphertext":"b87781948a1befd247bff51ef4063f716cf6c2d3481163e9a8f42e1f9bb74145","cipherparams":{"iv":"dc4926b48a105133d2f16b96833abf1e"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":2,"p":1,"r":8,"salt":"004244bbdc51cadda545b1cfa43cff9ed2ae88e08c61f1479dbb45410722f8f0"},"mac":"39990c1684557447940d4c69e06b1b82b2aceacb43f284df65c956daf3046b85"},"id":"ce541d8d-c79b-40f8-9f8c-20f59616faba","version":3}
--- a/accounts/manager.go
+++ b/accounts/manager.go
@ -1,229 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package accounts
-
-import (
-	"reflect"
-	"sort"
-	"sync"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/event"
-)
-
-// Config contains the settings of the global account manager.
-//
-// TODO(rjl493456442, karalabe, holiman): Get rid of this when account management
-// is removed in favor of Clef.
-type Config struct {
-	InsecureUnlockAllowed bool // Whether account unlocking in insecure environment is allowed
-}
-
-// Manager is an overarching account manager that can communicate with various
-// backends for signing transactions.
-type Manager struct {
-	config   *Config                    // Global account manager configurations
-	backends map[reflect.Type][]Backend // Index of backends currently registered
-	updaters []event.Subscription       // Wallet update subscriptions for all backends
-	updates  chan WalletEvent           // Subscription sink for backend wallet changes
-	wallets  []Wallet                   // Cache of all wallets from all registered backends
-
-	feed event.Feed // Wallet feed notifying of arrivals/departures
-
-	quit chan chan error
-	lock sync.RWMutex
-}
-
-// NewManager creates a generic account manager to sign transaction via various
-// supported backends.
-func NewManager(config *Config, backends ...Backend) *Manager {
-	// Retrieve the initial list of wallets from the backends and sort by URL
-	var wallets []Wallet
-	for _, backend := range backends {
-		wallets = merge(wallets, backend.Wallets()...)
-	}
-	// Subscribe to wallet notifications from all backends
-	updates := make(chan WalletEvent, 4*len(backends))
-
-	subs := make([]event.Subscription, len(backends))
-	for i, backend := range backends {
-		subs[i] = backend.Subscribe(updates)
-	}
-	// Assemble the account manager and return
-	am := &Manager{
-		config:   config,
-		backends: make(map[reflect.Type][]Backend),
-		updaters: subs,
-		updates:  updates,
-		wallets:  wallets,
-		quit:     make(chan chan error),
-	}
-	for _, backend := range backends {
-		kind := reflect.TypeOf(backend)
-		am.backends[kind] = append(am.backends[kind], backend)
-	}
-	go am.update()
-
-	return am
-}
-
-// Close terminates the account manager's internal notification processes.
-func (am *Manager) Close() error {
-	errc := make(chan error)
-	am.quit <- errc
-	return <-errc
-}
-
-// Config returns the configuration of account manager.
-func (am *Manager) Config() *Config {
-	return am.config
-}
-
-// update is the wallet event loop listening for notifications from the backends
-// and updating the cache of wallets.
-func (am *Manager) update() {
-	// Close all subscriptions when the manager terminates
-	defer func() {
-		am.lock.Lock()
-		for _, sub := range am.updaters {
-			sub.Unsubscribe()
-		}
-		am.updaters = nil
-		am.lock.Unlock()
-	}()
-
-	// Loop until termination
-	for {
-		select {
-		case event := <-am.updates:
-			// Wallet event arrived, update local cache
-			am.lock.Lock()
-			switch event.Kind {
-			case WalletArrived:
-				am.wallets = merge(am.wallets, event.Wallet)
-			case WalletDropped:
-				am.wallets = drop(am.wallets, event.Wallet)
-			}
-			am.lock.Unlock()
-
-			// Notify any listeners of the event
-			am.feed.Send(event)
-
-		case errc := <-am.quit:
-			// Manager terminating, return
-			errc <- nil
-			return
-		}
-	}
-}
-
-// Backends retrieves the backend(s) with the given type from the account manager.
-func (am *Manager) Backends(kind reflect.Type) []Backend {
-	return am.backends[kind]
-}
-
-// Wallets returns all signer accounts registered under this account manager.
-func (am *Manager) Wallets() []Wallet {
-	am.lock.RLock()
-	defer am.lock.RUnlock()
-
-	cpy := make([]Wallet, len(am.wallets))
-	copy(cpy, am.wallets)
-	return cpy
-}
-
-// Wallet retrieves the wallet associated with a particular URL.
-func (am *Manager) Wallet(url string) (Wallet, error) {
-	am.lock.RLock()
-	defer am.lock.RUnlock()
-
-	parsed, err := parseURL(url)
-	if err != nil {
-		return nil, err
-	}
-	for _, wallet := range am.Wallets() {
-		if wallet.URL() == parsed {
-			return wallet, nil
-		}
-	}
-	return nil, ErrUnknownWallet
-}
-
-// Accounts returns all account addresses of all wallets within the account manager
-func (am *Manager) Accounts() []common.Address {
-	am.lock.RLock()
-	defer am.lock.RUnlock()
-
-	addresses := make([]common.Address, 0) // return [] instead of nil if empty
-	for _, wallet := range am.wallets {
-		for _, account := range wallet.Accounts() {
-			addresses = append(addresses, account.Address)
-		}
-	}
-	return addresses
-}
-
-// Find attempts to locate the wallet corresponding to a specific account. Since
-// accounts can be dynamically added to and removed from wallets, this method has
-// a linear runtime in the number of wallets.
-func (am *Manager) Find(account Account) (Wallet, error) {
-	am.lock.RLock()
-	defer am.lock.RUnlock()
-
-	for _, wallet := range am.wallets {
-		if wallet.Contains(account) {
-			return wallet, nil
-		}
-	}
-	return nil, ErrUnknownAccount
-}
-
-// Subscribe creates an async subscription to receive notifications when the
-// manager detects the arrival or departure of a wallet from any of its backends.
-func (am *Manager) Subscribe(sink chan<- WalletEvent) event.Subscription {
-	return am.feed.Subscribe(sink)
-}
-
-// merge is a sorted analogue of append for wallets, where the ordering of the
-// origin list is preserved by inserting new wallets at the correct position.
-//
-// The original slice is assumed to be already sorted by URL.
-func merge(slice []Wallet, wallets ...Wallet) []Wallet {
-	for _, wallet := range wallets {
-		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
-		if n == len(slice) {
-			slice = append(slice, wallet)
-			continue
-		}
-		slice = append(slice[:n], append([]Wallet{wallet}, slice[n:]...)...)
-	}
-	return slice
-}
-
-// drop is the couterpart of merge, which looks up wallets from within the sorted
-// cache and removes the ones specified.
-func drop(slice []Wallet, wallets ...Wallet) []Wallet {
-	for _, wallet := range wallets {
-		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
-		if n == len(slice) {
-			// Wallet not found, may happen during startup
-			continue
-		}
-		slice = append(slice[:n], slice[n+1:]...)
-	}
-	return slice
-}
--- a/accounts/url_test.go
+++ b/accounts/url_test.go
@ -1,96 +0,0 @@
-// Copyright 2018 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package accounts
-
-import (
-	"testing"
-)
-
-func TestURLParsing(t *testing.T) {
-	url, err := parseURL("https://ethereum.org")
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	if url.Scheme != "https" {
-		t.Errorf("expected: %v, got: %v", "https", url.Scheme)
-	}
-	if url.Path != "ethereum.org" {
-		t.Errorf("expected: %v, got: %v", "ethereum.org", url.Path)
-	}
-
-	_, err = parseURL("ethereum.org")
-	if err == nil {
-		t.Error("expected err, got: nil")
-	}
-}
-
-func TestURLString(t *testing.T) {
-	url := URL{Scheme: "https", Path: "ethereum.org"}
-	if url.String() != "https://ethereum.org" {
-		t.Errorf("expected: %v, got: %v", "https://ethereum.org", url.String())
-	}
-
-	url = URL{Scheme: "", Path: "ethereum.org"}
-	if url.String() != "ethereum.org" {
-		t.Errorf("expected: %v, got: %v", "ethereum.org", url.String())
-	}
-}
-
-func TestURLMarshalJSON(t *testing.T) {
-	url := URL{Scheme: "https", Path: "ethereum.org"}
-	json, err := url.MarshalJSON()
-	if err != nil {
-		t.Errorf("unexpcted error: %v", err)
-	}
-	if string(json) != "\"https://ethereum.org\"" {
-		t.Errorf("expected: %v, got: %v", "\"https://ethereum.org\"", string(json))
-	}
-}
-
-func TestURLUnmarshalJSON(t *testing.T) {
-	url := &URL{}
-	err := url.UnmarshalJSON([]byte("\"https://ethereum.org\""))
-	if err != nil {
-		t.Errorf("unexpcted error: %v", err)
-	}
-	if url.Scheme != "https" {
-		t.Errorf("expected: %v, got: %v", "https", url.Scheme)
-	}
-	if url.Path != "ethereum.org" {
-		t.Errorf("expected: %v, got: %v", "https", url.Path)
-	}
-}
-
-func TestURLComparison(t *testing.T) {
-	tests := []struct {
-		urlA   URL
-		urlB   URL
-		expect int
-	}{
-		{URL{"https", "ethereum.org"}, URL{"https", "ethereum.org"}, 0},
-		{URL{"http", "ethereum.org"}, URL{"https", "ethereum.org"}, -1},
-		{URL{"https", "ethereum.org/a"}, URL{"https", "ethereum.org"}, 1},
-		{URL{"https", "abc.org"}, URL{"https", "ethereum.org"}, -1},
-	}
-
-	for i, tt := range tests {
-		result := tt.urlA.Cmp(tt.urlB)
-		if result != tt.expect {
-			t.Errorf("test %d: cmp mismatch: expected: %d, got: %d", i, tt.expect, result)
-		}
-	}
-}
--- a/accounts/usbwallet/trezor.go
+++ b/accounts/usbwallet/trezor.go
@ -1,365 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// This file contains the implementation for interacting with the Trezor hardware
-// wallets. The wire protocol spec can be found on the SatoshiLabs website:
-// https://doc.satoshilabs.com/trezor-tech/api-protobuf.html
-
-package usbwallet
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/accounts/usbwallet/trezor"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/golang/protobuf/proto"
-)
-
-// ErrTrezorPINNeeded is returned if opening the trezor requires a PIN code. In
-// this case, the calling application should display a pinpad and send back the
-// encoded passphrase.
-var ErrTrezorPINNeeded = errors.New("trezor: pin needed")
-
-// ErrTrezorPassphraseNeeded is returned if opening the trezor requires a passphrase
-var ErrTrezorPassphraseNeeded = errors.New("trezor: passphrase needed")
-
-// errTrezorReplyInvalidHeader is the error message returned by a Trezor data exchange
-// if the device replies with a mismatching header. This usually means the device
-// is in browser mode.
-var errTrezorReplyInvalidHeader = errors.New("trezor: invalid reply header")
-
-// trezorDriver implements the communication with a Trezor hardware wallet.
-type trezorDriver struct {
-	device         io.ReadWriter // USB device connection to communicate through
-	version        [3]uint32     // Current version of the Trezor firmware
-	label          string        // Current textual label of the Trezor device
-	pinwait        bool          // Flags whether the device is waiting for PIN entry
-	passphrasewait bool          // Flags whether the device is waiting for passphrase entry
-	failure        error         // Any failure that would make the device unusable
-	log            log.Logger    // Contextual logger to tag the trezor with its id
-}
-
-// newTrezorDriver creates a new instance of a Trezor USB protocol driver.
-func newTrezorDriver(logger log.Logger) driver {
-	return &trezorDriver{
-		log: logger,
-	}
-}
-
-// Status implements accounts.Wallet, always whether the Trezor is opened, closed
-// or whether the Ethereum app was not started on it.
-func (w *trezorDriver) Status() (string, error) {
-	if w.failure != nil {
-		return fmt.Sprintf("Failed: %v", w.failure), w.failure
-	}
-	if w.device == nil {
-		return "Closed", w.failure
-	}
-	if w.pinwait {
-		return fmt.Sprintf("Trezor v%d.%d.%d '%s' waiting for PIN", w.version[0], w.version[1], w.version[2], w.label), w.failure
-	}
-	return fmt.Sprintf("Trezor v%d.%d.%d '%s' online", w.version[0], w.version[1], w.version[2], w.label), w.failure
-}
-
-// Open implements usbwallet.driver, attempting to initialize the connection to
-// the Trezor hardware wallet. Initializing the Trezor is a two or three phase operation:
-//  * The first phase is to initialize the connection and read the wallet's
-//    features. This phase is invoked if the provided passphrase is empty. The
-//    device will display the pinpad as a result and will return an appropriate
-//    error to notify the user that a second open phase is needed.
-//  * The second phase is to unlock access to the Trezor, which is done by the
-//    user actually providing a passphrase mapping a keyboard keypad to the pin
-//    number of the user (shuffled according to the pinpad displayed).
-//  * If needed the device will ask for passphrase which will require calling
-//    open again with the actual passphrase (3rd phase)
-func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
-	w.device, w.failure = device, nil
-
-	// If phase 1 is requested, init the connection and wait for user callback
-	if passphrase == "" && !w.passphrasewait {
-		// If we're already waiting for a PIN entry, insta-return
-		if w.pinwait {
-			return ErrTrezorPINNeeded
-		}
-		// Initialize a connection to the device
-		features := new(trezor.Features)
-		if _, err := w.trezorExchange(&trezor.Initialize{}, features); err != nil {
-			return err
-		}
-		w.version = [3]uint32{features.GetMajorVersion(), features.GetMinorVersion(), features.GetPatchVersion()}
-		w.label = features.GetLabel()
-
-		// Do a manual ping, forcing the device to ask for its PIN and Passphrase
-		askPin := true
-		askPassphrase := true
-		res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin, PassphraseProtection: &askPassphrase}, new(trezor.PinMatrixRequest), new(trezor.PassphraseRequest), new(trezor.Success))
-		if err != nil {
-			return err
-		}
-		// Only return the PIN request if the device wasn't unlocked until now
-		switch res {
-		case 0:
-			w.pinwait = true
-			return ErrTrezorPINNeeded
-		case 1:
-			w.pinwait = false
-			w.passphrasewait = true
-			return ErrTrezorPassphraseNeeded
-		case 2:
-			return nil // responded with trezor.Success
-		}
-	}
-	// Phase 2 requested with actual PIN entry
-	if w.pinwait {
-		w.pinwait = false
-		res, err := w.trezorExchange(&trezor.PinMatrixAck{Pin: &passphrase}, new(trezor.Success), new(trezor.PassphraseRequest))
-		if err != nil {
-			w.failure = err
-			return err
-		}
-		if res == 1 {
-			w.passphrasewait = true
-			return ErrTrezorPassphraseNeeded
-		}
-	} else if w.passphrasewait {
-		w.passphrasewait = false
-		if _, err := w.trezorExchange(&trezor.PassphraseAck{Passphrase: &passphrase}, new(trezor.Success)); err != nil {
-			w.failure = err
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Close implements usbwallet.driver, cleaning up and metadata maintained within
-// the Trezor driver.
-func (w *trezorDriver) Close() error {
-	w.version, w.label, w.pinwait = [3]uint32{}, "", false
-	return nil
-}
-
-// Heartbeat implements usbwallet.driver, performing a sanity check against the
-// Trezor to see if it's still online.
-func (w *trezorDriver) Heartbeat() error {
-	if _, err := w.trezorExchange(&trezor.Ping{}, new(trezor.Success)); err != nil {
-		w.failure = err
-		return err
-	}
-	return nil
-}
-
-// Derive implements usbwallet.driver, sending a derivation request to the Trezor
-// and returning the Ethereum address located on that derivation path.
-func (w *trezorDriver) Derive(path accounts.DerivationPath) (common.Address, error) {
-	return w.trezorDerive(path)
-}
-
-// SignTx implements usbwallet.driver, sending the transaction to the Trezor and
-// waiting for the user to confirm or deny the transaction.
-func (w *trezorDriver) SignTx(path accounts.DerivationPath, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
-	if w.device == nil {
-		return common.Address{}, nil, accounts.ErrWalletClosed
-	}
-	return w.trezorSign(path, tx, chainID)
-}
-
-// trezorDerive sends a derivation request to the Trezor device and returns the
-// Ethereum address located on that path.
-func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, error) {
-	address := new(trezor.EthereumAddress)
-	if _, err := w.trezorExchange(&trezor.EthereumGetAddress{AddressN: derivationPath}, address); err != nil {
-		return common.Address{}, err
-	}
-	if addr := address.GetAddressBin(); len(addr) > 0 { // Older firmwares use binary fomats
-		return common.BytesToAddress(addr), nil
-	}
-	if addr := address.GetAddressHex(); len(addr) > 0 { // Newer firmwares use hexadecimal fomats
-		return common.HexToAddress(addr), nil
-	}
-	return common.Address{}, errors.New("missing derived address")
-}
-
-// trezorSign sends the transaction to the Trezor wallet, and waits for the user
-// to confirm or deny the transaction.
-func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction, chainID *big.Int) (common.Address, *types.Transaction, error) {
-	// Create the transaction initiation message
-	data := tx.Data()
-	length := uint32(len(data))
-
-	request := &trezor.EthereumSignTx{
-		AddressN:   derivationPath,
-		Nonce:      new(big.Int).SetUint64(tx.Nonce()).Bytes(),
-		GasPrice:   tx.GasPrice().Bytes(),
-		GasLimit:   new(big.Int).SetUint64(tx.Gas()).Bytes(),
-		Value:      tx.Value().Bytes(),
-		DataLength: &length,
-	}
-	if to := tx.To(); to != nil {
-		// Non contract deploy, set recipient explicitly
-		hex := to.Hex()
-		request.ToHex = &hex     // Newer firmwares (old will ignore)
-		request.ToBin = (*to)[:] // Older firmwares (new will ignore)
-	}
-	if length > 1024 { // Send the data chunked if that was requested
-		request.DataInitialChunk, data = data[:1024], data[1024:]
-	} else {
-		request.DataInitialChunk, data = data, nil
-	}
-	if chainID != nil { // EIP-155 transaction, set chain ID explicitly (only 32 bit is supported!?)
-		id := uint32(chainID.Int64())
-		request.ChainId = &id
-	}
-	// Send the initiation message and stream content until a signature is returned
-	response := new(trezor.EthereumTxRequest)
-	if _, err := w.trezorExchange(request, response); err != nil {
-		return common.Address{}, nil, err
-	}
-	for response.DataLength != nil && int(*response.DataLength) <= len(data) {
-		chunk := data[:*response.DataLength]
-		data = data[*response.DataLength:]
-
-		if _, err := w.trezorExchange(&trezor.EthereumTxAck{DataChunk: chunk}, response); err != nil {
-			return common.Address{}, nil, err
-		}
-	}
-	// Extract the Ethereum signature and do a sanity validation
-	if len(response.GetSignatureR()) == 0 || len(response.GetSignatureS()) == 0 || response.GetSignatureV() == 0 {
-		return common.Address{}, nil, errors.New("reply lacks signature")
-	}
-	signature := append(append(response.GetSignatureR(), response.GetSignatureS()...), byte(response.GetSignatureV()))
-
-	// Create the correct signer and signature transform based on the chain ID
-	var signer types.Signer
-	if chainID == nil {
-		signer = new(types.HomesteadSigner)
-	} else {
-		signer = types.NewEIP155Signer(chainID)
-		signature[64] -= byte(chainID.Uint64()*2 + 35)
-	}
-	// Inject the final signature into the transaction and sanity check the sender
-	signed, err := tx.WithSignature(signer, signature)
-	if err != nil {
-		return common.Address{}, nil, err
-	}
-	sender, err := types.Sender(signer, signed)
-	if err != nil {
-		return common.Address{}, nil, err
-	}
-	return sender, signed, nil
-}
-
-// trezorExchange performs a data exchange with the Trezor wallet, sending it a
-// message and retrieving the response. If multiple responses are possible, the
-// method will also return the index of the destination object used.
-func (w *trezorDriver) trezorExchange(req proto.Message, results ...proto.Message) (int, error) {
-	// Construct the original message payload to chunk up
-	data, err := proto.Marshal(req)
-	if err != nil {
-		return 0, err
-	}
-	payload := make([]byte, 8+len(data))
-	copy(payload, []byte{0x23, 0x23})
-	binary.BigEndian.PutUint16(payload[2:], trezor.Type(req))
-	binary.BigEndian.PutUint32(payload[4:], uint32(len(data)))
-	copy(payload[8:], data)
-
-	// Stream all the chunks to the device
-	chunk := make([]byte, 64)
-	chunk[0] = 0x3f // Report ID magic number
-
-	for len(payload) > 0 {
-		// Construct the new message to stream, padding with zeroes if needed
-		if len(payload) > 63 {
-			copy(chunk[1:], payload[:63])
-			payload = payload[63:]
-		} else {
-			copy(chunk[1:], payload)
-			copy(chunk[1+len(payload):], make([]byte, 63-len(payload)))
-			payload = nil
-		}
-		// Send over to the device
-		w.log.Trace("Data chunk sent to the Trezor", "chunk", hexutil.Bytes(chunk))
-		if _, err := w.device.Write(chunk); err != nil {
-			return 0, err
-		}
-	}
-	// Stream the reply back from the wallet in 64 byte chunks
-	var (
-		kind  uint16
-		reply []byte
-	)
-	for {
-		// Read the next chunk from the Trezor wallet
-		if _, err := io.ReadFull(w.device, chunk); err != nil {
-			return 0, err
-		}
-		w.log.Trace("Data chunk received from the Trezor", "chunk", hexutil.Bytes(chunk))
-
-		// Make sure the transport header matches
-		if chunk[0] != 0x3f || (len(reply) == 0 && (chunk[1] != 0x23 || chunk[2] != 0x23)) {
-			return 0, errTrezorReplyInvalidHeader
-		}
-		// If it's the first chunk, retrieve the reply message type and total message length
-		var payload []byte
-
-		if len(reply) == 0 {
-			kind = binary.BigEndian.Uint16(chunk[3:5])
-			reply = make([]byte, 0, int(binary.BigEndian.Uint32(chunk[5:9])))
-			payload = chunk[9:]
-		} else {
-			payload = chunk[1:]
-		}
-		// Append to the reply and stop when filled up
-		if left := cap(reply) - len(reply); left > len(payload) {
-			reply = append(reply, payload...)
-		} else {
-			reply = append(reply, payload[:left]...)
-			break
-		}
-	}
-	// Try to parse the reply into the requested reply message
-	if kind == uint16(trezor.MessageType_MessageType_Failure) {
-		// Trezor returned a failure, extract and return the message
-		failure := new(trezor.Failure)
-		if err := proto.Unmarshal(reply, failure); err != nil {
-			return 0, err
-		}
-		return 0, errors.New("trezor: " + failure.GetMessage())
-	}
-	if kind == uint16(trezor.MessageType_MessageType_ButtonRequest) {
-		// Trezor is waiting for user confirmation, ack and wait for the next message
-		return w.trezorExchange(&trezor.ButtonAck{}, results...)
-	}
-	for i, res := range results {
-		if trezor.Type(res) == kind {
-			return i, proto.Unmarshal(reply, res)
-		}
-	}
-	expected := make([]string, len(results))
-	for i, res := range results {
-		expected[i] = trezor.Name(trezor.Type(res))
-	}
-	return 0, fmt.Errorf("trezor: expected reply types %s, got %s", expected, trezor.Name(kind))
-}
--- a/accounts/usbwallet/trezor/messages-common.pb.go
+++ b/accounts/usbwallet/trezor/messages-common.pb.go
@ -1,811 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages-common.proto
-
-package trezor
-
-import (
-	fmt "fmt"
-	math "math"
-
-	proto "github.com/golang/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-type Failure_FailureType int32
-
-const (
-	Failure_Failure_UnexpectedMessage Failure_FailureType = 1
-	Failure_Failure_ButtonExpected    Failure_FailureType = 2
-	Failure_Failure_DataError         Failure_FailureType = 3
-	Failure_Failure_ActionCancelled   Failure_FailureType = 4
-	Failure_Failure_PinExpected       Failure_FailureType = 5
-	Failure_Failure_PinCancelled      Failure_FailureType = 6
-	Failure_Failure_PinInvalid        Failure_FailureType = 7
-	Failure_Failure_InvalidSignature  Failure_FailureType = 8
-	Failure_Failure_ProcessError      Failure_FailureType = 9
-	Failure_Failure_NotEnoughFunds    Failure_FailureType = 10
-	Failure_Failure_NotInitialized    Failure_FailureType = 11
-	Failure_Failure_PinMismatch       Failure_FailureType = 12
-	Failure_Failure_FirmwareError     Failure_FailureType = 99
-)
-
-var Failure_FailureType_name = map[int32]string{
-	1:  "Failure_UnexpectedMessage",
-	2:  "Failure_ButtonExpected",
-	3:  "Failure_DataError",
-	4:  "Failure_ActionCancelled",
-	5:  "Failure_PinExpected",
-	6:  "Failure_PinCancelled",
-	7:  "Failure_PinInvalid",
-	8:  "Failure_InvalidSignature",
-	9:  "Failure_ProcessError",
-	10: "Failure_NotEnoughFunds",
-	11: "Failure_NotInitialized",
-	12: "Failure_PinMismatch",
-	99: "Failure_FirmwareError",
-}
-
-var Failure_FailureType_value = map[string]int32{
-	"Failure_UnexpectedMessage": 1,
-	"Failure_ButtonExpected":    2,
-	"Failure_DataError":         3,
-	"Failure_ActionCancelled":   4,
-	"Failure_PinExpected":       5,
-	"Failure_PinCancelled":      6,
-	"Failure_PinInvalid":        7,
-	"Failure_InvalidSignature":  8,
-	"Failure_ProcessError":      9,
-	"Failure_NotEnoughFunds":    10,
-	"Failure_NotInitialized":    11,
-	"Failure_PinMismatch":       12,
-	"Failure_FirmwareError":     99,
-}
-
-func (x Failure_FailureType) Enum() *Failure_FailureType {
-	p := new(Failure_FailureType)
-	*p = x
-	return p
-}
-
-func (x Failure_FailureType) String() string {
-	return proto.EnumName(Failure_FailureType_name, int32(x))
-}
-
-func (x *Failure_FailureType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(Failure_FailureType_value, data, "Failure_FailureType")
-	if err != nil {
-		return err
-	}
-	*x = Failure_FailureType(value)
-	return nil
-}
-
-func (Failure_FailureType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{1, 0}
-}
-
-//*
-// Type of button request
-type ButtonRequest_ButtonRequestType int32
-
-const (
-	ButtonRequest_ButtonRequest_Other                 ButtonRequest_ButtonRequestType = 1
-	ButtonRequest_ButtonRequest_FeeOverThreshold      ButtonRequest_ButtonRequestType = 2
-	ButtonRequest_ButtonRequest_ConfirmOutput         ButtonRequest_ButtonRequestType = 3
-	ButtonRequest_ButtonRequest_ResetDevice           ButtonRequest_ButtonRequestType = 4
-	ButtonRequest_ButtonRequest_ConfirmWord           ButtonRequest_ButtonRequestType = 5
-	ButtonRequest_ButtonRequest_WipeDevice            ButtonRequest_ButtonRequestType = 6
-	ButtonRequest_ButtonRequest_ProtectCall           ButtonRequest_ButtonRequestType = 7
-	ButtonRequest_ButtonRequest_SignTx                ButtonRequest_ButtonRequestType = 8
-	ButtonRequest_ButtonRequest_FirmwareCheck         ButtonRequest_ButtonRequestType = 9
-	ButtonRequest_ButtonRequest_Address               ButtonRequest_ButtonRequestType = 10
-	ButtonRequest_ButtonRequest_PublicKey             ButtonRequest_ButtonRequestType = 11
-	ButtonRequest_ButtonRequest_MnemonicWordCount     ButtonRequest_ButtonRequestType = 12
-	ButtonRequest_ButtonRequest_MnemonicInput         ButtonRequest_ButtonRequestType = 13
-	ButtonRequest_ButtonRequest_PassphraseType        ButtonRequest_ButtonRequestType = 14
-	ButtonRequest_ButtonRequest_UnknownDerivationPath ButtonRequest_ButtonRequestType = 15
-)
-
-var ButtonRequest_ButtonRequestType_name = map[int32]string{
-	1:  "ButtonRequest_Other",
-	2:  "ButtonRequest_FeeOverThreshold",
-	3:  "ButtonRequest_ConfirmOutput",
-	4:  "ButtonRequest_ResetDevice",
-	5:  "ButtonRequest_ConfirmWord",
-	6:  "ButtonRequest_WipeDevice",
-	7:  "ButtonRequest_ProtectCall",
-	8:  "ButtonRequest_SignTx",
-	9:  "ButtonRequest_FirmwareCheck",
-	10: "ButtonRequest_Address",
-	11: "ButtonRequest_PublicKey",
-	12: "ButtonRequest_MnemonicWordCount",
-	13: "ButtonRequest_MnemonicInput",
-	14: "ButtonRequest_PassphraseType",
-	15: "ButtonRequest_UnknownDerivationPath",
-}
-
-var ButtonRequest_ButtonRequestType_value = map[string]int32{
-	"ButtonRequest_Other":                 1,
-	"ButtonRequest_FeeOverThreshold":      2,
-	"ButtonRequest_ConfirmOutput":         3,
-	"ButtonRequest_ResetDevice":           4,
-	"ButtonRequest_ConfirmWord":           5,
-	"ButtonRequest_WipeDevice":            6,
-	"ButtonRequest_ProtectCall":           7,
-	"ButtonRequest_SignTx":                8,
-	"ButtonRequest_FirmwareCheck":         9,
-	"ButtonRequest_Address":               10,
-	"ButtonRequest_PublicKey":             11,
-	"ButtonRequest_MnemonicWordCount":     12,
-	"ButtonRequest_MnemonicInput":         13,
-	"ButtonRequest_PassphraseType":        14,
-	"ButtonRequest_UnknownDerivationPath": 15,
-}
-
-func (x ButtonRequest_ButtonRequestType) Enum() *ButtonRequest_ButtonRequestType {
-	p := new(ButtonRequest_ButtonRequestType)
-	*p = x
-	return p
-}
-
-func (x ButtonRequest_ButtonRequestType) String() string {
-	return proto.EnumName(ButtonRequest_ButtonRequestType_name, int32(x))
-}
-
-func (x *ButtonRequest_ButtonRequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(ButtonRequest_ButtonRequestType_value, data, "ButtonRequest_ButtonRequestType")
-	if err != nil {
-		return err
-	}
-	*x = ButtonRequest_ButtonRequestType(value)
-	return nil
-}
-
-func (ButtonRequest_ButtonRequestType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{2, 0}
-}
-
-//*
-// Type of PIN request
-type PinMatrixRequest_PinMatrixRequestType int32
-
-const (
-	PinMatrixRequest_PinMatrixRequestType_Current   PinMatrixRequest_PinMatrixRequestType = 1
-	PinMatrixRequest_PinMatrixRequestType_NewFirst  PinMatrixRequest_PinMatrixRequestType = 2
-	PinMatrixRequest_PinMatrixRequestType_NewSecond PinMatrixRequest_PinMatrixRequestType = 3
-)
-
-var PinMatrixRequest_PinMatrixRequestType_name = map[int32]string{
-	1: "PinMatrixRequestType_Current",
-	2: "PinMatrixRequestType_NewFirst",
-	3: "PinMatrixRequestType_NewSecond",
-}
-
-var PinMatrixRequest_PinMatrixRequestType_value = map[string]int32{
-	"PinMatrixRequestType_Current":   1,
-	"PinMatrixRequestType_NewFirst":  2,
-	"PinMatrixRequestType_NewSecond": 3,
-}
-
-func (x PinMatrixRequest_PinMatrixRequestType) Enum() *PinMatrixRequest_PinMatrixRequestType {
-	p := new(PinMatrixRequest_PinMatrixRequestType)
-	*p = x
-	return p
-}
-
-func (x PinMatrixRequest_PinMatrixRequestType) String() string {
-	return proto.EnumName(PinMatrixRequest_PinMatrixRequestType_name, int32(x))
-}
-
-func (x *PinMatrixRequest_PinMatrixRequestType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(PinMatrixRequest_PinMatrixRequestType_value, data, "PinMatrixRequest_PinMatrixRequestType")
-	if err != nil {
-		return err
-	}
-	*x = PinMatrixRequest_PinMatrixRequestType(value)
-	return nil
-}
-
-func (PinMatrixRequest_PinMatrixRequestType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{4, 0}
-}
-
-//*
-// Response: Success of the previous request
-// @end
-type Success struct {
-	Message              *string  `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *Success) Reset()         { *m = Success{} }
-func (m *Success) String() string { return proto.CompactTextString(m) }
-func (*Success) ProtoMessage()    {}
-func (*Success) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{0}
-}
-
-func (m *Success) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Success.Unmarshal(m, b)
-}
-func (m *Success) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Success.Marshal(b, m, deterministic)
-}
-func (m *Success) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Success.Merge(m, src)
-}
-func (m *Success) XXX_Size() int {
-	return xxx_messageInfo_Success.Size(m)
-}
-func (m *Success) XXX_DiscardUnknown() {
-	xxx_messageInfo_Success.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Success proto.InternalMessageInfo
-
-func (m *Success) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-//*
-// Response: Failure of the previous request
-// @end
-type Failure struct {
-	Code                 *Failure_FailureType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.Failure_FailureType" json:"code,omitempty"`
-	Message              *string              `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
-	XXX_unrecognized     []byte               `json:"-"`
-	XXX_sizecache        int32                `json:"-"`
-}
-
-func (m *Failure) Reset()         { *m = Failure{} }
-func (m *Failure) String() string { return proto.CompactTextString(m) }
-func (*Failure) ProtoMessage()    {}
-func (*Failure) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{1}
-}
-
-func (m *Failure) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Failure.Unmarshal(m, b)
-}
-func (m *Failure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Failure.Marshal(b, m, deterministic)
-}
-func (m *Failure) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_Failure.Merge(m, src)
-}
-func (m *Failure) XXX_Size() int {
-	return xxx_messageInfo_Failure.Size(m)
-}
-func (m *Failure) XXX_DiscardUnknown() {
-	xxx_messageInfo_Failure.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Failure proto.InternalMessageInfo
-
-func (m *Failure) GetCode() Failure_FailureType {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return Failure_Failure_UnexpectedMessage
-}
-
-func (m *Failure) GetMessage() string {
-	if m != nil && m.Message != nil {
-		return *m.Message
-	}
-	return ""
-}
-
-//*
-// Response: Device is waiting for HW button press.
-// @auxstart
-// @next ButtonAck
-type ButtonRequest struct {
-	Code                 *ButtonRequest_ButtonRequestType `protobuf:"varint,1,opt,name=code,enum=hw.trezor.messages.common.ButtonRequest_ButtonRequestType" json:"code,omitempty"`
-	Data                 *string                          `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
-	XXX_unrecognized     []byte                           `json:"-"`
-	XXX_sizecache        int32                            `json:"-"`
-}
-
-func (m *ButtonRequest) Reset()         { *m = ButtonRequest{} }
-func (m *ButtonRequest) String() string { return proto.CompactTextString(m) }
-func (*ButtonRequest) ProtoMessage()    {}
-func (*ButtonRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{2}
-}
-
-func (m *ButtonRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ButtonRequest.Unmarshal(m, b)
-}
-func (m *ButtonRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ButtonRequest.Marshal(b, m, deterministic)
-}
-func (m *ButtonRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ButtonRequest.Merge(m, src)
-}
-func (m *ButtonRequest) XXX_Size() int {
-	return xxx_messageInfo_ButtonRequest.Size(m)
-}
-func (m *ButtonRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_ButtonRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ButtonRequest proto.InternalMessageInfo
-
-func (m *ButtonRequest) GetCode() ButtonRequest_ButtonRequestType {
-	if m != nil && m.Code != nil {
-		return *m.Code
-	}
-	return ButtonRequest_ButtonRequest_Other
-}
-
-func (m *ButtonRequest) GetData() string {
-	if m != nil && m.Data != nil {
-		return *m.Data
-	}
-	return ""
-}
-
-//*
-// Request: Computer agrees to wait for HW button press
-// @auxend
-type ButtonAck struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *ButtonAck) Reset()         { *m = ButtonAck{} }
-func (m *ButtonAck) String() string { return proto.CompactTextString(m) }
-func (*ButtonAck) ProtoMessage()    {}
-func (*ButtonAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{3}
-}
-
-func (m *ButtonAck) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ButtonAck.Unmarshal(m, b)
-}
-func (m *ButtonAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ButtonAck.Marshal(b, m, deterministic)
-}
-func (m *ButtonAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ButtonAck.Merge(m, src)
-}
-func (m *ButtonAck) XXX_Size() int {
-	return xxx_messageInfo_ButtonAck.Size(m)
-}
-func (m *ButtonAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_ButtonAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ButtonAck proto.InternalMessageInfo
-
-//*
-// Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
-// @auxstart
-// @next PinMatrixAck
-type PinMatrixRequest struct {
-	Type                 *PinMatrixRequest_PinMatrixRequestType `protobuf:"varint,1,opt,name=type,enum=hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType" json:"type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                               `json:"-"`
-	XXX_unrecognized     []byte                                 `json:"-"`
-	XXX_sizecache        int32                                  `json:"-"`
-}
-
-func (m *PinMatrixRequest) Reset()         { *m = PinMatrixRequest{} }
-func (m *PinMatrixRequest) String() string { return proto.CompactTextString(m) }
-func (*PinMatrixRequest) ProtoMessage()    {}
-func (*PinMatrixRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{4}
-}
-
-func (m *PinMatrixRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PinMatrixRequest.Unmarshal(m, b)
-}
-func (m *PinMatrixRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PinMatrixRequest.Marshal(b, m, deterministic)
-}
-func (m *PinMatrixRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PinMatrixRequest.Merge(m, src)
-}
-func (m *PinMatrixRequest) XXX_Size() int {
-	return xxx_messageInfo_PinMatrixRequest.Size(m)
-}
-func (m *PinMatrixRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_PinMatrixRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PinMatrixRequest proto.InternalMessageInfo
-
-func (m *PinMatrixRequest) GetType() PinMatrixRequest_PinMatrixRequestType {
-	if m != nil && m.Type != nil {
-		return *m.Type
-	}
-	return PinMatrixRequest_PinMatrixRequestType_Current
-}
-
-//*
-// Request: Computer responds with encoded PIN
-// @auxend
-type PinMatrixAck struct {
-	Pin                  *string  `protobuf:"bytes,1,req,name=pin" json:"pin,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *PinMatrixAck) Reset()         { *m = PinMatrixAck{} }
-func (m *PinMatrixAck) String() string { return proto.CompactTextString(m) }
-func (*PinMatrixAck) ProtoMessage()    {}
-func (*PinMatrixAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{5}
-}
-
-func (m *PinMatrixAck) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PinMatrixAck.Unmarshal(m, b)
-}
-func (m *PinMatrixAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PinMatrixAck.Marshal(b, m, deterministic)
-}
-func (m *PinMatrixAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PinMatrixAck.Merge(m, src)
-}
-func (m *PinMatrixAck) XXX_Size() int {
-	return xxx_messageInfo_PinMatrixAck.Size(m)
-}
-func (m *PinMatrixAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_PinMatrixAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PinMatrixAck proto.InternalMessageInfo
-
-func (m *PinMatrixAck) GetPin() string {
-	if m != nil && m.Pin != nil {
-		return *m.Pin
-	}
-	return ""
-}
-
-//*
-// Response: Device awaits encryption passphrase
-// @auxstart
-// @next PassphraseAck
-type PassphraseRequest struct {
-	OnDevice             *bool    `protobuf:"varint,1,opt,name=on_device,json=onDevice" json:"on_device,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *PassphraseRequest) Reset()         { *m = PassphraseRequest{} }
-func (m *PassphraseRequest) String() string { return proto.CompactTextString(m) }
-func (*PassphraseRequest) ProtoMessage()    {}
-func (*PassphraseRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{6}
-}
-
-func (m *PassphraseRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PassphraseRequest.Unmarshal(m, b)
-}
-func (m *PassphraseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PassphraseRequest.Marshal(b, m, deterministic)
-}
-func (m *PassphraseRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PassphraseRequest.Merge(m, src)
-}
-func (m *PassphraseRequest) XXX_Size() int {
-	return xxx_messageInfo_PassphraseRequest.Size(m)
-}
-func (m *PassphraseRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_PassphraseRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseRequest proto.InternalMessageInfo
-
-func (m *PassphraseRequest) GetOnDevice() bool {
-	if m != nil && m.OnDevice != nil {
-		return *m.OnDevice
-	}
-	return false
-}
-
-//*
-// Request: Send passphrase back
-// @next PassphraseStateRequest
-type PassphraseAck struct {
-	Passphrase           *string  `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
-	State                []byte   `protobuf:"bytes,2,opt,name=state" json:"state,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *PassphraseAck) Reset()         { *m = PassphraseAck{} }
-func (m *PassphraseAck) String() string { return proto.CompactTextString(m) }
-func (*PassphraseAck) ProtoMessage()    {}
-func (*PassphraseAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{7}
-}
-
-func (m *PassphraseAck) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PassphraseAck.Unmarshal(m, b)
-}
-func (m *PassphraseAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PassphraseAck.Marshal(b, m, deterministic)
-}
-func (m *PassphraseAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PassphraseAck.Merge(m, src)
-}
-func (m *PassphraseAck) XXX_Size() int {
-	return xxx_messageInfo_PassphraseAck.Size(m)
-}
-func (m *PassphraseAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_PassphraseAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseAck proto.InternalMessageInfo
-
-func (m *PassphraseAck) GetPassphrase() string {
-	if m != nil && m.Passphrase != nil {
-		return *m.Passphrase
-	}
-	return ""
-}
-
-func (m *PassphraseAck) GetState() []byte {
-	if m != nil {
-		return m.State
-	}
-	return nil
-}
-
-//*
-// Response: Device awaits passphrase state
-// @next PassphraseStateAck
-type PassphraseStateRequest struct {
-	State                []byte   `protobuf:"bytes,1,opt,name=state" json:"state,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *PassphraseStateRequest) Reset()         { *m = PassphraseStateRequest{} }
-func (m *PassphraseStateRequest) String() string { return proto.CompactTextString(m) }
-func (*PassphraseStateRequest) ProtoMessage()    {}
-func (*PassphraseStateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{8}
-}
-
-func (m *PassphraseStateRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PassphraseStateRequest.Unmarshal(m, b)
-}
-func (m *PassphraseStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PassphraseStateRequest.Marshal(b, m, deterministic)
-}
-func (m *PassphraseStateRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PassphraseStateRequest.Merge(m, src)
-}
-func (m *PassphraseStateRequest) XXX_Size() int {
-	return xxx_messageInfo_PassphraseStateRequest.Size(m)
-}
-func (m *PassphraseStateRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_PassphraseStateRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseStateRequest proto.InternalMessageInfo
-
-func (m *PassphraseStateRequest) GetState() []byte {
-	if m != nil {
-		return m.State
-	}
-	return nil
-}
-
-//*
-// Request: Send passphrase state back
-// @auxend
-type PassphraseStateAck struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *PassphraseStateAck) Reset()         { *m = PassphraseStateAck{} }
-func (m *PassphraseStateAck) String() string { return proto.CompactTextString(m) }
-func (*PassphraseStateAck) ProtoMessage()    {}
-func (*PassphraseStateAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{9}
-}
-
-func (m *PassphraseStateAck) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PassphraseStateAck.Unmarshal(m, b)
-}
-func (m *PassphraseStateAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PassphraseStateAck.Marshal(b, m, deterministic)
-}
-func (m *PassphraseStateAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_PassphraseStateAck.Merge(m, src)
-}
-func (m *PassphraseStateAck) XXX_Size() int {
-	return xxx_messageInfo_PassphraseStateAck.Size(m)
-}
-func (m *PassphraseStateAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_PassphraseStateAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PassphraseStateAck proto.InternalMessageInfo
-
-//*
-// Structure representing BIP32 (hierarchical deterministic) node
-// Used for imports of private key into the device and exporting public key out of device
-// @embed
-type HDNodeType struct {
-	Depth                *uint32  `protobuf:"varint,1,req,name=depth" json:"depth,omitempty"`
-	Fingerprint          *uint32  `protobuf:"varint,2,req,name=fingerprint" json:"fingerprint,omitempty"`
-	ChildNum             *uint32  `protobuf:"varint,3,req,name=child_num,json=childNum" json:"child_num,omitempty"`
-	ChainCode            []byte   `protobuf:"bytes,4,req,name=chain_code,json=chainCode" json:"chain_code,omitempty"`
-	PrivateKey           []byte   `protobuf:"bytes,5,opt,name=private_key,json=privateKey" json:"private_key,omitempty"`
-	PublicKey            []byte   `protobuf:"bytes,6,opt,name=public_key,json=publicKey" json:"public_key,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *HDNodeType) Reset()         { *m = HDNodeType{} }
-func (m *HDNodeType) String() string { return proto.CompactTextString(m) }
-func (*HDNodeType) ProtoMessage()    {}
-func (*HDNodeType) Descriptor() ([]byte, []int) {
-	return fileDescriptor_aaf30d059fdbc38d, []int{10}
-}
-
-func (m *HDNodeType) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_HDNodeType.Unmarshal(m, b)
-}
-func (m *HDNodeType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_HDNodeType.Marshal(b, m, deterministic)
-}
-func (m *HDNodeType) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_HDNodeType.Merge(m, src)
-}
-func (m *HDNodeType) XXX_Size() int {
-	return xxx_messageInfo_HDNodeType.Size(m)
-}
-func (m *HDNodeType) XXX_DiscardUnknown() {
-	xxx_messageInfo_HDNodeType.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_HDNodeType proto.InternalMessageInfo
-
-func (m *HDNodeType) GetDepth() uint32 {
-	if m != nil && m.Depth != nil {
-		return *m.Depth
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetFingerprint() uint32 {
-	if m != nil && m.Fingerprint != nil {
-		return *m.Fingerprint
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetChildNum() uint32 {
-	if m != nil && m.ChildNum != nil {
-		return *m.ChildNum
-	}
-	return 0
-}
-
-func (m *HDNodeType) GetChainCode() []byte {
-	if m != nil {
-		return m.ChainCode
-	}
-	return nil
-}
-
-func (m *HDNodeType) GetPrivateKey() []byte {
-	if m != nil {
-		return m.PrivateKey
-	}
-	return nil
-}
-
-func (m *HDNodeType) GetPublicKey() []byte {
-	if m != nil {
-		return m.PublicKey
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterEnum("hw.trezor.messages.common.Failure_FailureType", Failure_FailureType_name, Failure_FailureType_value)
-	proto.RegisterEnum("hw.trezor.messages.common.ButtonRequest_ButtonRequestType", ButtonRequest_ButtonRequestType_name, ButtonRequest_ButtonRequestType_value)
-	proto.RegisterEnum("hw.trezor.messages.common.PinMatrixRequest_PinMatrixRequestType", PinMatrixRequest_PinMatrixRequestType_name, PinMatrixRequest_PinMatrixRequestType_value)
-	proto.RegisterType((*Success)(nil), "hw.trezor.messages.common.Success")
-	proto.RegisterType((*Failure)(nil), "hw.trezor.messages.common.Failure")
-	proto.RegisterType((*ButtonRequest)(nil), "hw.trezor.messages.common.ButtonRequest")
-	proto.RegisterType((*ButtonAck)(nil), "hw.trezor.messages.common.ButtonAck")
-	proto.RegisterType((*PinMatrixRequest)(nil), "hw.trezor.messages.common.PinMatrixRequest")
-	proto.RegisterType((*PinMatrixAck)(nil), "hw.trezor.messages.common.PinMatrixAck")
-	proto.RegisterType((*PassphraseRequest)(nil), "hw.trezor.messages.common.PassphraseRequest")
-	proto.RegisterType((*PassphraseAck)(nil), "hw.trezor.messages.common.PassphraseAck")
-	proto.RegisterType((*PassphraseStateRequest)(nil), "hw.trezor.messages.common.PassphraseStateRequest")
-	proto.RegisterType((*PassphraseStateAck)(nil), "hw.trezor.messages.common.PassphraseStateAck")
-	proto.RegisterType((*HDNodeType)(nil), "hw.trezor.messages.common.HDNodeType")
-}
-
-func init() { proto.RegisterFile("messages-common.proto", fileDescriptor_aaf30d059fdbc38d) }
-
-var fileDescriptor_aaf30d059fdbc38d = []byte{
-	// 846 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xcd, 0x52, 0x23, 0x37,
-	0x10, 0x2e, 0xff, 0x80, 0xed, 0xb6, 0xd9, 0x08, 0xc5, 0x80, 0x09, 0xb0, 0x38, 0xc3, 0x21, 0x5c,
-	0xe2, 0x4a, 0xe5, 0x98, 0x53, 0x58, 0x83, 0x2b, 0xd4, 0x16, 0x86, 0x1a, 0xd8, 0xda, 0xa3, 0x4b,
-	0xd1, 0xf4, 0x32, 0x2a, 0xcf, 0x48, 0x13, 0x8d, 0x06, 0xf0, 0x5e, 0xf2, 0x6a, 0x79, 0x89, 0xbc,
-	0x42, 0xaa, 0x52, 0xb9, 0xe4, 0x11, 0xb6, 0x34, 0x3f, 0x78, 0xc6, 0x66, 0x39, 0xcd, 0xe8, 0xfb,
-	0xbe, 0xee, 0x96, 0xba, 0x3f, 0x09, 0x76, 0x42, 0x8c, 0x63, 0x76, 0x8f, 0xf1, 0x8f, 0x5c, 0x85,
-	0xa1, 0x92, 0xa3, 0x48, 0x2b, 0xa3, 0xe8, 0xbe, 0xff, 0x38, 0x32, 0x1a, 0x3f, 0x2b, 0x3d, 0x2a,
-	0x04, 0xa3, 0x4c, 0xe0, 0x9c, 0x40, 0xeb, 0x36, 0xe1, 0x1c, 0xe3, 0x98, 0x0e, 0xa0, 0x95, 0xb3,
-	0x83, 0xda, 0xb0, 0x76, 0xda, 0x71, 0x8b, 0xa5, 0xf3, 0x77, 0x03, 0x5a, 0x13, 0x26, 0x82, 0x44,
-	0x23, 0x7d, 0x07, 0x4d, 0xae, 0xbc, 0x4c, 0xf2, 0xe6, 0xe7, 0xd1, 0xe8, 0xab, 0xa9, 0x47, 0x79,
-	0x44, 0xf1, 0xbd, 0x5b, 0x44, 0xe8, 0xa6, 0xb1, 0xe5, 0x4a, 0xf5, 0x6a, 0xa5, 0xff, 0xea, 0xd0,
-	0x2d, 0xe9, 0xe9, 0x11, 0xec, 0xe7, 0xcb, 0xd9, 0x07, 0x89, 0x4f, 0x11, 0x72, 0x83, 0xde, 0x55,
-	0x26, 0x26, 0x35, 0xfa, 0x1d, 0xec, 0x16, 0xf4, 0xbb, 0xc4, 0x18, 0x25, 0x2f, 0x72, 0x09, 0xa9,
-	0xd3, 0x1d, 0xd8, 0x2e, 0xb8, 0x73, 0x66, 0xd8, 0x85, 0xd6, 0x4a, 0x93, 0x06, 0x3d, 0x80, 0xbd,
-	0x02, 0x3e, 0xe3, 0x46, 0x28, 0x39, 0x66, 0x92, 0x63, 0x10, 0xa0, 0x47, 0x9a, 0x74, 0x0f, 0xbe,
-	0x2d, 0xc8, 0x1b, 0xb1, 0x4c, 0xb6, 0x41, 0x07, 0xd0, 0x2f, 0x11, 0xcb, 0x90, 0x4d, 0xba, 0x0b,
-	0xb4, 0xc4, 0x5c, 0xca, 0x07, 0x16, 0x08, 0x8f, 0xb4, 0xe8, 0x21, 0x0c, 0x0a, 0x3c, 0x07, 0x6f,
-	0xc5, 0xbd, 0x64, 0x26, 0xd1, 0x48, 0xda, 0x95, 0x7c, 0x5a, 0xd9, 0xf6, 0x67, 0xfb, 0xeb, 0x94,
-	0x8f, 0x34, 0x55, 0xe6, 0x42, 0xaa, 0xe4, 0xde, 0x9f, 0x24, 0xd2, 0x8b, 0x09, 0xac, 0x70, 0x97,
-	0x52, 0x18, 0xc1, 0x02, 0xf1, 0x19, 0x3d, 0xd2, 0x5d, 0xd9, 0xfa, 0x95, 0x88, 0x43, 0x66, 0xb8,
-	0x4f, 0x7a, 0x74, 0x1f, 0x76, 0x0a, 0x62, 0x22, 0x74, 0xf8, 0xc8, 0x34, 0x66, 0xb5, 0xb8, 0xf3,
-	0x4f, 0x13, 0xb6, 0xb2, 0xbe, 0xb9, 0xf8, 0x47, 0x82, 0xb1, 0xa1, 0xd3, 0xca, 0x74, 0x7f, 0x79,
-	0x65, 0xba, 0x95, 0xb8, 0xea, 0xaa, 0x34, 0x69, 0x0a, 0x4d, 0x8f, 0x19, 0x96, 0x8f, 0x39, 0xfd,
-	0x77, 0xfe, 0x6f, 0xc0, 0xf6, 0x9a, 0xde, 0xee, 0xbf, 0x02, 0xce, 0xae, 0x8d, 0x8f, 0x9a, 0xd4,
-	0xa8, 0x03, 0x6f, 0xab, 0xc4, 0x04, 0xf1, 0xfa, 0x01, 0xf5, 0x9d, 0xaf, 0x31, 0xf6, 0x55, 0x60,
-	0x67, 0x7d, 0x0c, 0x07, 0x55, 0xcd, 0x58, 0xc9, 0x4f, 0x42, 0x87, 0xd7, 0x89, 0x89, 0x12, 0x43,
-	0x1a, 0xd6, 0x47, 0x55, 0x81, 0x8b, 0x31, 0x9a, 0x73, 0x7c, 0x10, 0x1c, 0x49, 0x73, 0x9d, 0xce,
-	0xe3, 0x3f, 0x2a, 0x6d, 0xa7, 0x7f, 0x08, 0x83, 0x2a, 0xfd, 0x51, 0x44, 0x98, 0x07, 0x6f, 0xae,
-	0x07, 0xdf, 0x68, 0x65, 0x90, 0x9b, 0x31, 0x0b, 0x02, 0xd2, 0xb2, 0xa3, 0xae, 0xd2, 0xd6, 0x07,
-	0x77, 0x4f, 0xa4, 0xbd, 0xbe, 0xeb, 0x62, 0x3e, 0x63, 0x1f, 0xf9, 0x9c, 0x74, 0xec, 0xe8, 0xaa,
-	0x82, 0x33, 0xcf, 0xd3, 0x18, 0x5b, 0x2b, 0x1c, 0xc0, 0xde, 0x4a, 0xd1, 0xe4, 0xf7, 0x40, 0xf0,
-	0xf7, 0xb8, 0x20, 0x5d, 0x7a, 0x02, 0xc7, 0x55, 0xf2, 0x4a, 0x62, 0xa8, 0xa4, 0xe0, 0xf6, 0x3c,
-	0x63, 0x95, 0x48, 0x43, 0x7a, 0xeb, 0xd5, 0x0b, 0xd1, 0xa5, 0xb4, 0x3d, 0xdb, 0xa2, 0x43, 0x38,
-	0x5c, 0x29, 0xc1, 0xe2, 0x38, 0xf2, 0x35, 0x8b, 0xd3, 0xbb, 0x49, 0xde, 0xd0, 0x1f, 0xe0, 0xa4,
-	0xaa, 0xf8, 0x20, 0xe7, 0x52, 0x3d, 0xca, 0x73, 0xd4, 0xe2, 0x81, 0xd9, 0xcb, 0x75, 0xc3, 0x8c,
-	0x4f, 0xbe, 0x71, 0xba, 0xd0, 0xc9, 0x84, 0x67, 0x7c, 0xee, 0xfc, 0x5b, 0x03, 0x62, 0x2d, 0xca,
-	0x8c, 0x16, 0x4f, 0x85, 0xf1, 0xee, 0xa0, 0x69, 0x16, 0x51, 0x61, 0xbc, 0x5f, 0x5f, 0x31, 0xde,
-	0x6a, 0xe8, 0x1a, 0x90, 0xd9, 0xcf, 0x66, 0x73, 0xfe, 0x84, 0xfe, 0x4b, 0xac, 0x3d, 0xda, 0x4b,
-	0xf8, 0x6c, 0x9c, 0x68, 0x8d, 0xd2, 0x90, 0x1a, 0xfd, 0x1e, 0x8e, 0x5e, 0x54, 0x4c, 0xf1, 0x71,
-	0x22, 0x74, 0x6c, 0x48, 0xdd, 0x1a, 0xf3, 0x6b, 0x92, 0x5b, 0xe4, 0x4a, 0x7a, 0xa4, 0xe1, 0x0c,
-	0xa1, 0xf7, 0xac, 0x39, 0xe3, 0x73, 0x4a, 0xa0, 0x11, 0x09, 0x39, 0xa8, 0x0d, 0xeb, 0xa7, 0x1d,
-	0xd7, 0xfe, 0x3a, 0x3f, 0xc1, 0xf6, 0xb2, 0xaf, 0x45, 0x37, 0x0e, 0xa0, 0xa3, 0xe4, 0xcc, 0x4b,
-	0x1d, 0x96, 0xb6, 0xa4, 0xed, 0xb6, 0x95, 0xcc, 0x1c, 0xe7, 0x5c, 0xc0, 0xd6, 0x32, 0xc2, 0x26,
-	0x7d, 0x0b, 0x10, 0x3d, 0x03, 0xf9, 0xdb, 0x5d, 0x42, 0x68, 0x1f, 0x36, 0x62, 0xc3, 0x4c, 0xf6,
-	0xd8, 0xf6, 0xdc, 0x6c, 0xe1, 0x8c, 0x60, 0x77, 0x99, 0xe6, 0xd6, 0x42, 0x45, 0xf5, 0x67, 0x7d,
-	0xad, 0xac, 0xef, 0x03, 0x5d, 0xd1, 0xdb, 0x61, 0xfe, 0x55, 0x03, 0xf8, 0xed, 0x7c, 0xaa, 0xbc,
-	0xec, 0xbd, 0xee, 0xc3, 0x86, 0x87, 0x91, 0xf1, 0xd3, 0x13, 0x6e, 0xb9, 0xd9, 0x82, 0x0e, 0xa1,
-	0xfb, 0x49, 0xc8, 0x7b, 0xd4, 0x91, 0x16, 0xd2, 0x0c, 0xea, 0x29, 0x57, 0x86, 0xec, 0x81, 0xb9,
-	0x2f, 0x02, 0x6f, 0x26, 0x93, 0x70, 0xd0, 0x48, 0xf9, 0x76, 0x0a, 0x4c, 0x93, 0x90, 0x1e, 0x01,
-	0x70, 0x9f, 0x09, 0x39, 0x4b, 0x9f, 0xa6, 0xe6, 0xb0, 0x7e, 0xda, 0x73, 0x3b, 0x29, 0x32, 0xb6,
-	0x6f, 0xcc, 0x31, 0x74, 0xa3, 0xd4, 0x6f, 0x38, 0x9b, 0xe3, 0x62, 0xb0, 0x91, 0x6e, 0x1a, 0x72,
-	0xe8, 0x3d, 0x2e, 0x6c, 0x7c, 0x94, 0xde, 0x8e, 0x94, 0xdf, 0x4c, 0xf9, 0x4e, 0x54, 0xdc, 0x97,
-	0x2f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xb2, 0x7d, 0x20, 0xa6, 0x35, 0x07, 0x00, 0x00,
-}
--- a/accounts/usbwallet/trezor/messages-common.proto
+++ b/accounts/usbwallet/trezor/messages-common.proto
@ -1,147 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages-common.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.common;
-
-/**
- * Response: Success of the previous request
- * @end
- */
-message Success {
-    optional string message = 1;    // human readable description of action or request-specific payload
-}
-
-/**
- * Response: Failure of the previous request
- * @end
- */
-message Failure {
-    optional FailureType code = 1;  // computer-readable definition of the error state
-    optional string message = 2;    // human-readable message of the error state
-    enum FailureType {
-        Failure_UnexpectedMessage = 1;
-        Failure_ButtonExpected = 2;
-        Failure_DataError = 3;
-        Failure_ActionCancelled = 4;
-        Failure_PinExpected = 5;
-        Failure_PinCancelled = 6;
-        Failure_PinInvalid = 7;
-        Failure_InvalidSignature = 8;
-        Failure_ProcessError = 9;
-        Failure_NotEnoughFunds = 10;
-        Failure_NotInitialized = 11;
-        Failure_PinMismatch = 12;
-        Failure_FirmwareError = 99;
-    }
-}
-
-/**
- * Response: Device is waiting for HW button press.
- * @auxstart
- * @next ButtonAck
- */
-message ButtonRequest {
-    optional ButtonRequestType code = 1;
-    optional string data = 2;
-    /**
-    * Type of button request
-    */
-    enum ButtonRequestType {
-        ButtonRequest_Other = 1;
-        ButtonRequest_FeeOverThreshold = 2;
-        ButtonRequest_ConfirmOutput = 3;
-        ButtonRequest_ResetDevice = 4;
-        ButtonRequest_ConfirmWord = 5;
-        ButtonRequest_WipeDevice = 6;
-        ButtonRequest_ProtectCall = 7;
-        ButtonRequest_SignTx = 8;
-        ButtonRequest_FirmwareCheck = 9;
-        ButtonRequest_Address = 10;
-        ButtonRequest_PublicKey = 11;
-        ButtonRequest_MnemonicWordCount = 12;
-        ButtonRequest_MnemonicInput = 13;
-        ButtonRequest_PassphraseType = 14;
-        ButtonRequest_UnknownDerivationPath = 15;
-    }
-}
-
-/**
- * Request: Computer agrees to wait for HW button press
- * @auxend
- */
-message ButtonAck {
-}
-
-/**
- * Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
- * @auxstart
- * @next PinMatrixAck
- */
-message PinMatrixRequest {
-    optional PinMatrixRequestType type = 1;
-    /**
-    * Type of PIN request
-    */
-    enum PinMatrixRequestType {
-        PinMatrixRequestType_Current = 1;
-        PinMatrixRequestType_NewFirst = 2;
-        PinMatrixRequestType_NewSecond = 3;
-    }
-}
-
-/**
- * Request: Computer responds with encoded PIN
- * @auxend
- */
-message PinMatrixAck {
-    required string pin = 1;    // matrix encoded PIN entered by user
-}
-
-/**
- * Response: Device awaits encryption passphrase
- * @auxstart
- * @next PassphraseAck
- */
-message PassphraseRequest {
-    optional bool on_device = 1;    // passphrase is being entered on the device
-}
-
-/**
- * Request: Send passphrase back
- * @next PassphraseStateRequest
- */
-message PassphraseAck {
-    optional string passphrase = 1;
-    optional bytes state = 2;       // expected device state
-}
-
-/**
- * Response: Device awaits passphrase state
- * @next PassphraseStateAck
- */
-message PassphraseStateRequest {
-    optional bytes state = 1;       // actual device state
-}
-
-/**
- * Request: Send passphrase state back
- * @auxend
- */
-message PassphraseStateAck {
-}
-
-/**
- * Structure representing BIP32 (hierarchical deterministic) node
- * Used for imports of private key into the device and exporting public key out of device
- * @embed
- */
-message HDNodeType {
-    required uint32 depth = 1;
-    required uint32 fingerprint = 2;
-    required uint32 child_num = 3;
-    required bytes chain_code = 4;
-    optional bytes private_key = 5;
-    optional bytes public_key = 6;
-}
--- a/accounts/usbwallet/trezor/messages-ethereum.pb.go
+++ b/accounts/usbwallet/trezor/messages-ethereum.pb.go
@ -1,698 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages-ethereum.proto
-
-package trezor
-
-import (
-	fmt "fmt"
-	math "math"
-
-	proto "github.com/golang/protobuf/proto"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-//*
-// Request: Ask device for public key corresponding to address_n path
-// @start
-// @next EthereumPublicKey
-// @next Failure
-type EthereumGetPublicKey struct {
-	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	ShowDisplay          *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumGetPublicKey) Reset()         { *m = EthereumGetPublicKey{} }
-func (m *EthereumGetPublicKey) String() string { return proto.CompactTextString(m) }
-func (*EthereumGetPublicKey) ProtoMessage()    {}
-func (*EthereumGetPublicKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{0}
-}
-
-func (m *EthereumGetPublicKey) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumGetPublicKey.Unmarshal(m, b)
-}
-func (m *EthereumGetPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumGetPublicKey.Marshal(b, m, deterministic)
-}
-func (m *EthereumGetPublicKey) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumGetPublicKey.Merge(m, src)
-}
-func (m *EthereumGetPublicKey) XXX_Size() int {
-	return xxx_messageInfo_EthereumGetPublicKey.Size(m)
-}
-func (m *EthereumGetPublicKey) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumGetPublicKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumGetPublicKey proto.InternalMessageInfo
-
-func (m *EthereumGetPublicKey) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumGetPublicKey) GetShowDisplay() bool {
-	if m != nil && m.ShowDisplay != nil {
-		return *m.ShowDisplay
-	}
-	return false
-}
-
-//*
-// Response: Contains public key derived from device private seed
-// @end
-type EthereumPublicKey struct {
-	Node                 *HDNodeType `protobuf:"bytes,1,opt,name=node" json:"node,omitempty"`
-	Xpub                 *string     `protobuf:"bytes,2,opt,name=xpub" json:"xpub,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
-}
-
-func (m *EthereumPublicKey) Reset()         { *m = EthereumPublicKey{} }
-func (m *EthereumPublicKey) String() string { return proto.CompactTextString(m) }
-func (*EthereumPublicKey) ProtoMessage()    {}
-func (*EthereumPublicKey) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{1}
-}
-
-func (m *EthereumPublicKey) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumPublicKey.Unmarshal(m, b)
-}
-func (m *EthereumPublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumPublicKey.Marshal(b, m, deterministic)
-}
-func (m *EthereumPublicKey) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumPublicKey.Merge(m, src)
-}
-func (m *EthereumPublicKey) XXX_Size() int {
-	return xxx_messageInfo_EthereumPublicKey.Size(m)
-}
-func (m *EthereumPublicKey) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumPublicKey.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumPublicKey proto.InternalMessageInfo
-
-func (m *EthereumPublicKey) GetNode() *HDNodeType {
-	if m != nil {
-		return m.Node
-	}
-	return nil
-}
-
-func (m *EthereumPublicKey) GetXpub() string {
-	if m != nil && m.Xpub != nil {
-		return *m.Xpub
-	}
-	return ""
-}
-
-//*
-// Request: Ask device for Ethereum address corresponding to address_n path
-// @start
-// @next EthereumAddress
-// @next Failure
-type EthereumGetAddress struct {
-	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	ShowDisplay          *bool    `protobuf:"varint,2,opt,name=show_display,json=showDisplay" json:"show_display,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumGetAddress) Reset()         { *m = EthereumGetAddress{} }
-func (m *EthereumGetAddress) String() string { return proto.CompactTextString(m) }
-func (*EthereumGetAddress) ProtoMessage()    {}
-func (*EthereumGetAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{2}
-}
-
-func (m *EthereumGetAddress) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumGetAddress.Unmarshal(m, b)
-}
-func (m *EthereumGetAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumGetAddress.Marshal(b, m, deterministic)
-}
-func (m *EthereumGetAddress) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumGetAddress.Merge(m, src)
-}
-func (m *EthereumGetAddress) XXX_Size() int {
-	return xxx_messageInfo_EthereumGetAddress.Size(m)
-}
-func (m *EthereumGetAddress) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumGetAddress.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumGetAddress proto.InternalMessageInfo
-
-func (m *EthereumGetAddress) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumGetAddress) GetShowDisplay() bool {
-	if m != nil && m.ShowDisplay != nil {
-		return *m.ShowDisplay
-	}
-	return false
-}
-
-//*
-// Response: Contains an Ethereum address derived from device private seed
-// @end
-type EthereumAddress struct {
-	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
-	AddressHex           *string  `protobuf:"bytes,2,opt,name=addressHex" json:"addressHex,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumAddress) Reset()         { *m = EthereumAddress{} }
-func (m *EthereumAddress) String() string { return proto.CompactTextString(m) }
-func (*EthereumAddress) ProtoMessage()    {}
-func (*EthereumAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{3}
-}
-
-func (m *EthereumAddress) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumAddress.Unmarshal(m, b)
-}
-func (m *EthereumAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumAddress.Marshal(b, m, deterministic)
-}
-func (m *EthereumAddress) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumAddress.Merge(m, src)
-}
-func (m *EthereumAddress) XXX_Size() int {
-	return xxx_messageInfo_EthereumAddress.Size(m)
-}
-func (m *EthereumAddress) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumAddress.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumAddress proto.InternalMessageInfo
-
-func (m *EthereumAddress) GetAddressBin() []byte {
-	if m != nil {
-		return m.AddressBin
-	}
-	return nil
-}
-
-func (m *EthereumAddress) GetAddressHex() string {
-	if m != nil && m.AddressHex != nil {
-		return *m.AddressHex
-	}
-	return ""
-}
-
-//*
-// Request: Ask device to sign transaction
-// All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
-// Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
-// @start
-// @next EthereumTxRequest
-// @next Failure
-type EthereumSignTx struct {
-	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce" json:"nonce,omitempty"`
-	GasPrice             []byte   `protobuf:"bytes,3,opt,name=gas_price,json=gasPrice" json:"gas_price,omitempty"`
-	GasLimit             []byte   `protobuf:"bytes,4,opt,name=gas_limit,json=gasLimit" json:"gas_limit,omitempty"`
-	ToBin                []byte   `protobuf:"bytes,5,opt,name=toBin" json:"toBin,omitempty"`
-	ToHex                *string  `protobuf:"bytes,11,opt,name=toHex" json:"toHex,omitempty"`
-	Value                []byte   `protobuf:"bytes,6,opt,name=value" json:"value,omitempty"`
-	DataInitialChunk     []byte   `protobuf:"bytes,7,opt,name=data_initial_chunk,json=dataInitialChunk" json:"data_initial_chunk,omitempty"`
-	DataLength           *uint32  `protobuf:"varint,8,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
-	ChainId              *uint32  `protobuf:"varint,9,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
-	TxType               *uint32  `protobuf:"varint,10,opt,name=tx_type,json=txType" json:"tx_type,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumSignTx) Reset()         { *m = EthereumSignTx{} }
-func (m *EthereumSignTx) String() string { return proto.CompactTextString(m) }
-func (*EthereumSignTx) ProtoMessage()    {}
-func (*EthereumSignTx) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{4}
-}
-
-func (m *EthereumSignTx) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumSignTx.Unmarshal(m, b)
-}
-func (m *EthereumSignTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumSignTx.Marshal(b, m, deterministic)
-}
-func (m *EthereumSignTx) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumSignTx.Merge(m, src)
-}
-func (m *EthereumSignTx) XXX_Size() int {
-	return xxx_messageInfo_EthereumSignTx.Size(m)
-}
-func (m *EthereumSignTx) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumSignTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumSignTx proto.InternalMessageInfo
-
-func (m *EthereumSignTx) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetNonce() []byte {
-	if m != nil {
-		return m.Nonce
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetGasPrice() []byte {
-	if m != nil {
-		return m.GasPrice
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetGasLimit() []byte {
-	if m != nil {
-		return m.GasLimit
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetToBin() []byte {
-	if m != nil {
-		return m.ToBin
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetToHex() string {
-	if m != nil && m.ToHex != nil {
-		return *m.ToHex
-	}
-	return ""
-}
-
-func (m *EthereumSignTx) GetValue() []byte {
-	if m != nil {
-		return m.Value
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetDataInitialChunk() []byte {
-	if m != nil {
-		return m.DataInitialChunk
-	}
-	return nil
-}
-
-func (m *EthereumSignTx) GetDataLength() uint32 {
-	if m != nil && m.DataLength != nil {
-		return *m.DataLength
-	}
-	return 0
-}
-
-func (m *EthereumSignTx) GetChainId() uint32 {
-	if m != nil && m.ChainId != nil {
-		return *m.ChainId
-	}
-	return 0
-}
-
-func (m *EthereumSignTx) GetTxType() uint32 {
-	if m != nil && m.TxType != nil {
-		return *m.TxType
-	}
-	return 0
-}
-
-//*
-// Response: Device asks for more data from transaction payload, or returns the signature.
-// If data_length is set, device awaits that many more bytes of payload.
-// Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
-// @end
-// @next EthereumTxAck
-type EthereumTxRequest struct {
-	DataLength           *uint32  `protobuf:"varint,1,opt,name=data_length,json=dataLength" json:"data_length,omitempty"`
-	SignatureV           *uint32  `protobuf:"varint,2,opt,name=signature_v,json=signatureV" json:"signature_v,omitempty"`
-	SignatureR           []byte   `protobuf:"bytes,3,opt,name=signature_r,json=signatureR" json:"signature_r,omitempty"`
-	SignatureS           []byte   `protobuf:"bytes,4,opt,name=signature_s,json=signatureS" json:"signature_s,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumTxRequest) Reset()         { *m = EthereumTxRequest{} }
-func (m *EthereumTxRequest) String() string { return proto.CompactTextString(m) }
-func (*EthereumTxRequest) ProtoMessage()    {}
-func (*EthereumTxRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{5}
-}
-
-func (m *EthereumTxRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumTxRequest.Unmarshal(m, b)
-}
-func (m *EthereumTxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumTxRequest.Marshal(b, m, deterministic)
-}
-func (m *EthereumTxRequest) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumTxRequest.Merge(m, src)
-}
-func (m *EthereumTxRequest) XXX_Size() int {
-	return xxx_messageInfo_EthereumTxRequest.Size(m)
-}
-func (m *EthereumTxRequest) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumTxRequest.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumTxRequest proto.InternalMessageInfo
-
-func (m *EthereumTxRequest) GetDataLength() uint32 {
-	if m != nil && m.DataLength != nil {
-		return *m.DataLength
-	}
-	return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureV() uint32 {
-	if m != nil && m.SignatureV != nil {
-		return *m.SignatureV
-	}
-	return 0
-}
-
-func (m *EthereumTxRequest) GetSignatureR() []byte {
-	if m != nil {
-		return m.SignatureR
-	}
-	return nil
-}
-
-func (m *EthereumTxRequest) GetSignatureS() []byte {
-	if m != nil {
-		return m.SignatureS
-	}
-	return nil
-}
-
-//*
-// Request: Transaction payload data.
-// @next EthereumTxRequest
-type EthereumTxAck struct {
-	DataChunk            []byte   `protobuf:"bytes,1,opt,name=data_chunk,json=dataChunk" json:"data_chunk,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumTxAck) Reset()         { *m = EthereumTxAck{} }
-func (m *EthereumTxAck) String() string { return proto.CompactTextString(m) }
-func (*EthereumTxAck) ProtoMessage()    {}
-func (*EthereumTxAck) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{6}
-}
-
-func (m *EthereumTxAck) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumTxAck.Unmarshal(m, b)
-}
-func (m *EthereumTxAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumTxAck.Marshal(b, m, deterministic)
-}
-func (m *EthereumTxAck) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumTxAck.Merge(m, src)
-}
-func (m *EthereumTxAck) XXX_Size() int {
-	return xxx_messageInfo_EthereumTxAck.Size(m)
-}
-func (m *EthereumTxAck) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumTxAck.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumTxAck proto.InternalMessageInfo
-
-func (m *EthereumTxAck) GetDataChunk() []byte {
-	if m != nil {
-		return m.DataChunk
-	}
-	return nil
-}
-
-//*
-// Request: Ask device to sign message
-// @start
-// @next EthereumMessageSignature
-// @next Failure
-type EthereumSignMessage struct {
-	AddressN             []uint32 `protobuf:"varint,1,rep,name=address_n,json=addressN" json:"address_n,omitempty"`
-	Message              []byte   `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumSignMessage) Reset()         { *m = EthereumSignMessage{} }
-func (m *EthereumSignMessage) String() string { return proto.CompactTextString(m) }
-func (*EthereumSignMessage) ProtoMessage()    {}
-func (*EthereumSignMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{7}
-}
-
-func (m *EthereumSignMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumSignMessage.Unmarshal(m, b)
-}
-func (m *EthereumSignMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumSignMessage.Marshal(b, m, deterministic)
-}
-func (m *EthereumSignMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumSignMessage.Merge(m, src)
-}
-func (m *EthereumSignMessage) XXX_Size() int {
-	return xxx_messageInfo_EthereumSignMessage.Size(m)
-}
-func (m *EthereumSignMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumSignMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumSignMessage proto.InternalMessageInfo
-
-func (m *EthereumSignMessage) GetAddressN() []uint32 {
-	if m != nil {
-		return m.AddressN
-	}
-	return nil
-}
-
-func (m *EthereumSignMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-//*
-// Response: Signed message
-// @end
-type EthereumMessageSignature struct {
-	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
-	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	AddressHex           *string  `protobuf:"bytes,3,opt,name=addressHex" json:"addressHex,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumMessageSignature) Reset()         { *m = EthereumMessageSignature{} }
-func (m *EthereumMessageSignature) String() string { return proto.CompactTextString(m) }
-func (*EthereumMessageSignature) ProtoMessage()    {}
-func (*EthereumMessageSignature) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{8}
-}
-
-func (m *EthereumMessageSignature) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumMessageSignature.Unmarshal(m, b)
-}
-func (m *EthereumMessageSignature) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumMessageSignature.Marshal(b, m, deterministic)
-}
-func (m *EthereumMessageSignature) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumMessageSignature.Merge(m, src)
-}
-func (m *EthereumMessageSignature) XXX_Size() int {
-	return xxx_messageInfo_EthereumMessageSignature.Size(m)
-}
-func (m *EthereumMessageSignature) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumMessageSignature.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumMessageSignature proto.InternalMessageInfo
-
-func (m *EthereumMessageSignature) GetAddressBin() []byte {
-	if m != nil {
-		return m.AddressBin
-	}
-	return nil
-}
-
-func (m *EthereumMessageSignature) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-func (m *EthereumMessageSignature) GetAddressHex() string {
-	if m != nil && m.AddressHex != nil {
-		return *m.AddressHex
-	}
-	return ""
-}
-
-//*
-// Request: Ask device to verify message
-// @start
-// @next Success
-// @next Failure
-type EthereumVerifyMessage struct {
-	AddressBin           []byte   `protobuf:"bytes,1,opt,name=addressBin" json:"addressBin,omitempty"`
-	Signature            []byte   `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
-	Message              []byte   `protobuf:"bytes,3,opt,name=message" json:"message,omitempty"`
-	AddressHex           *string  `protobuf:"bytes,4,opt,name=addressHex" json:"addressHex,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
-}
-
-func (m *EthereumVerifyMessage) Reset()         { *m = EthereumVerifyMessage{} }
-func (m *EthereumVerifyMessage) String() string { return proto.CompactTextString(m) }
-func (*EthereumVerifyMessage) ProtoMessage()    {}
-func (*EthereumVerifyMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_cb33f46ba915f15c, []int{9}
-}
-
-func (m *EthereumVerifyMessage) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EthereumVerifyMessage.Unmarshal(m, b)
-}
-func (m *EthereumVerifyMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EthereumVerifyMessage.Marshal(b, m, deterministic)
-}
-func (m *EthereumVerifyMessage) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_EthereumVerifyMessage.Merge(m, src)
-}
-func (m *EthereumVerifyMessage) XXX_Size() int {
-	return xxx_messageInfo_EthereumVerifyMessage.Size(m)
-}
-func (m *EthereumVerifyMessage) XXX_DiscardUnknown() {
-	xxx_messageInfo_EthereumVerifyMessage.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EthereumVerifyMessage proto.InternalMessageInfo
-
-func (m *EthereumVerifyMessage) GetAddressBin() []byte {
-	if m != nil {
-		return m.AddressBin
-	}
-	return nil
-}
-
-func (m *EthereumVerifyMessage) GetSignature() []byte {
-	if m != nil {
-		return m.Signature
-	}
-	return nil
-}
-
-func (m *EthereumVerifyMessage) GetMessage() []byte {
-	if m != nil {
-		return m.Message
-	}
-	return nil
-}
-
-func (m *EthereumVerifyMessage) GetAddressHex() string {
-	if m != nil && m.AddressHex != nil {
-		return *m.AddressHex
-	}
-	return ""
-}
-
-func init() {
-	proto.RegisterType((*EthereumGetPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumGetPublicKey")
-	proto.RegisterType((*EthereumPublicKey)(nil), "hw.trezor.messages.ethereum.EthereumPublicKey")
-	proto.RegisterType((*EthereumGetAddress)(nil), "hw.trezor.messages.ethereum.EthereumGetAddress")
-	proto.RegisterType((*EthereumAddress)(nil), "hw.trezor.messages.ethereum.EthereumAddress")
-	proto.RegisterType((*EthereumSignTx)(nil), "hw.trezor.messages.ethereum.EthereumSignTx")
-	proto.RegisterType((*EthereumTxRequest)(nil), "hw.trezor.messages.ethereum.EthereumTxRequest")
-	proto.RegisterType((*EthereumTxAck)(nil), "hw.trezor.messages.ethereum.EthereumTxAck")
-	proto.RegisterType((*EthereumSignMessage)(nil), "hw.trezor.messages.ethereum.EthereumSignMessage")
-	proto.RegisterType((*EthereumMessageSignature)(nil), "hw.trezor.messages.ethereum.EthereumMessageSignature")
-	proto.RegisterType((*EthereumVerifyMessage)(nil), "hw.trezor.messages.ethereum.EthereumVerifyMessage")
-}
-
-func init() { proto.RegisterFile("messages-ethereum.proto", fileDescriptor_cb33f46ba915f15c) }
-
-var fileDescriptor_cb33f46ba915f15c = []byte{
-	// 593 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
-	0x10, 0x95, 0x9b, 0xb4, 0x49, 0x26, 0x0d, 0x1f, 0xa6, 0x55, 0x17, 0x0a, 0x34, 0x18, 0x21, 0xe5,
-	0x00, 0x3e, 0x70, 0x43, 0xe2, 0xd2, 0x52, 0x44, 0x2b, 0x4a, 0x55, 0xdc, 0xa8, 0x57, 0x6b, 0x63,
-	0x6f, 0xe3, 0x55, 0x9d, 0xdd, 0xe0, 0x5d, 0xb7, 0x0e, 0x7f, 0x82, 0x23, 0xff, 0x87, 0x5f, 0x86,
-	0xf6, 0x2b, 0x71, 0x52, 0x54, 0x0e, 0xbd, 0x65, 0xde, 0xbc, 0x7d, 0xf3, 0x66, 0xf4, 0x62, 0xd8,
-	0x99, 0x10, 0x21, 0xf0, 0x98, 0x88, 0x77, 0x44, 0x66, 0xa4, 0x20, 0xe5, 0x24, 0x9c, 0x16, 0x5c,
-	0x72, 0x7f, 0x37, 0xbb, 0x09, 0x65, 0x41, 0x7e, 0xf2, 0x22, 0x74, 0x94, 0xd0, 0x51, 0x9e, 0x6d,
-	0xcf, 0x5f, 0x25, 0x7c, 0x32, 0xe1, 0xcc, 0xbc, 0x09, 0x2e, 0x60, 0xeb, 0xb3, 0xa5, 0x7c, 0x21,
-	0xf2, 0xac, 0x1c, 0xe5, 0x34, 0xf9, 0x4a, 0x66, 0xfe, 0x2e, 0x74, 0x70, 0x9a, 0x16, 0x44, 0x88,
-	0x98, 0x21, 0xaf, 0xdf, 0x18, 0xf4, 0xa2, 0xb6, 0x05, 0x4e, 0xfd, 0x57, 0xb0, 0x29, 0x32, 0x7e,
-	0x13, 0xa7, 0x54, 0x4c, 0x73, 0x3c, 0x43, 0x6b, 0x7d, 0x6f, 0xd0, 0x8e, 0xba, 0x0a, 0x3b, 0x34,
-	0x50, 0x30, 0x82, 0xc7, 0x4e, 0x77, 0x21, 0xfa, 0x01, 0x9a, 0x8c, 0xa7, 0x04, 0x79, 0x7d, 0x6f,
-	0xd0, 0x7d, 0xff, 0x26, 0xfc, 0x87, 0x5f, 0x6b, 0xee, 0xe8, 0xf0, 0x94, 0xa7, 0x64, 0x38, 0x9b,
-	0x92, 0x48, 0x3f, 0xf1, 0x7d, 0x68, 0x56, 0xd3, 0x72, 0xa4, 0x47, 0x75, 0x22, 0xfd, 0x3b, 0x18,
-	0x82, 0x5f, 0xf3, 0xbe, 0x6f, 0xdc, 0xdd, 0xdb, 0xf9, 0x77, 0x78, 0xe8, 0x54, 0x9d, 0xe4, 0x4b,
-	0x00, 0xab, 0x70, 0x40, 0x99, 0x76, 0xbf, 0x19, 0xd5, 0x90, 0x5a, 0xff, 0x88, 0x54, 0xd6, 0x62,
-	0x0d, 0x09, 0xfe, 0xac, 0xc1, 0x03, 0xa7, 0x79, 0x4e, 0xc7, 0x6c, 0x58, 0xdd, 0xed, 0x72, 0x0b,
-	0xd6, 0x19, 0x67, 0x09, 0xd1, 0x52, 0x9b, 0x91, 0x29, 0xd4, 0x93, 0x31, 0x16, 0xf1, 0xb4, 0xa0,
-	0x09, 0x41, 0x0d, 0xdd, 0x69, 0x8f, 0xb1, 0x38, 0x53, 0xb5, 0x6b, 0xe6, 0x74, 0x42, 0x25, 0x6a,
-	0xce, 0x9b, 0x27, 0xaa, 0x56, 0x7a, 0x92, 0x2b, 0xeb, 0xeb, 0x46, 0x4f, 0x17, 0x06, 0x55, 0x86,
-	0xbb, 0xda, 0xb0, 0x29, 0x14, 0x7a, 0x8d, 0xf3, 0x92, 0xa0, 0x0d, 0xc3, 0xd5, 0x85, 0xff, 0x16,
-	0xfc, 0x14, 0x4b, 0x1c, 0x53, 0x46, 0x25, 0xc5, 0x79, 0x9c, 0x64, 0x25, 0xbb, 0x42, 0x2d, 0x4d,
-	0x79, 0xa4, 0x3a, 0xc7, 0xa6, 0xf1, 0x49, 0xe1, 0xfe, 0x1e, 0x74, 0x35, 0x3b, 0x27, 0x6c, 0x2c,
-	0x33, 0xd4, 0xee, 0x7b, 0x83, 0x5e, 0x04, 0x0a, 0x3a, 0xd1, 0x88, 0xff, 0x14, 0xda, 0x49, 0x86,
-	0x29, 0x8b, 0x69, 0x8a, 0x3a, 0xba, 0xdb, 0xd2, 0xf5, 0x71, 0xea, 0xef, 0x40, 0x4b, 0x56, 0xb1,
-	0x9c, 0x4d, 0x09, 0x02, 0xdd, 0xd9, 0x90, 0x95, 0xca, 0x41, 0xf0, 0xdb, 0x5b, 0x44, 0x6a, 0x58,
-	0x45, 0xe4, 0x47, 0x49, 0x84, 0x5c, 0x1d, 0xe5, 0xdd, 0x1a, 0xb5, 0x07, 0x5d, 0x41, 0xc7, 0x0c,
-	0xcb, 0xb2, 0x20, 0xf1, 0xb5, 0xbe, 0x68, 0x2f, 0x82, 0x39, 0x74, 0xb1, 0x4c, 0x28, 0xec, 0x61,
-	0x17, 0x84, 0x68, 0x99, 0x20, 0xec, 0x71, 0x17, 0x84, 0xf3, 0x20, 0x84, 0xde, 0xc2, 0xd8, 0x7e,
-	0x72, 0xe5, 0xbf, 0x00, 0xed, 0xc0, 0x5e, 0xc9, 0xe4, 0xa5, 0xa3, 0x10, 0x7d, 0x9e, 0xe0, 0x04,
-	0x9e, 0xd4, 0xd3, 0xf0, 0xcd, 0x64, 0xff, 0xee, 0x48, 0x20, 0x68, 0xd9, 0xff, 0x88, 0x0d, 0x85,
-	0x2b, 0x83, 0x0a, 0x90, 0x53, 0xb3, 0x4a, 0xe7, 0xce, 0xda, 0x7f, 0x83, 0xfb, 0x1c, 0x3a, 0xf3,
-	0x3d, 0xac, 0xee, 0x02, 0x58, 0x89, 0x75, 0xe3, 0x56, 0xac, 0x7f, 0x79, 0xb0, 0xed, 0x46, 0x5f,
-	0x90, 0x82, 0x5e, 0xce, 0xdc, 0x2a, 0xf7, 0x9b, 0x5b, 0xdb, 0xb5, 0xb1, 0xb4, 0xeb, 0x8a, 0xa3,
-	0xe6, 0xaa, 0xa3, 0x83, 0x8f, 0xf0, 0x3a, 0xe1, 0x93, 0x50, 0x60, 0xc9, 0x45, 0x46, 0x73, 0x3c,
-	0x12, 0xee, 0x03, 0x93, 0xd3, 0x91, 0xf9, 0xe2, 0x8d, 0xca, 0xcb, 0x83, 0xed, 0xa1, 0x06, 0xad,
-	0x5b, 0xb7, 0xc2, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xce, 0x81, 0xc8, 0x59, 0x05, 0x00,
-	0x00,
-}
--- a/accounts/usbwallet/trezor/messages-ethereum.proto
+++ b/accounts/usbwallet/trezor/messages-ethereum.proto
@ -1,131 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages-ethereum.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.ethereum;
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessageEthereum";
-
-import "messages-common.proto";
-
-
-/**
- * Request: Ask device for public key corresponding to address_n path
- * @start
- * @next EthereumPublicKey
- * @next Failure
- */
-message EthereumGetPublicKey {
-    repeated uint32 address_n = 1;                                      // BIP-32 path to derive the key from master node
-    optional bool show_display = 2;                                     // optionally show on display before sending the result
-}
-
-/**
- * Response: Contains public key derived from device private seed
- * @end
- */
-message EthereumPublicKey {
-    optional hw.trezor.messages.common.HDNodeType node = 1;        // BIP32 public node
-    optional string xpub = 2;        // serialized form of public node
-}
-
-/**
- * Request: Ask device for Ethereum address corresponding to address_n path
- * @start
- * @next EthereumAddress
- * @next Failure
- */
-message EthereumGetAddress {
-    repeated uint32 address_n = 1;  // BIP-32 path to derive the key from master node
-    optional bool show_display = 2; // optionally show on display before sending the result
-}
-
-/**
- * Response: Contains an Ethereum address derived from device private seed
- * @end
- */
-message EthereumAddress {
-    optional bytes  addressBin = 1;    // Ethereum address as 20 bytes (legacy firmwares)
-    optional string addressHex = 2;    // Ethereum address as hex string (newer firmwares)
-}
-
-/**
- * Request: Ask device to sign transaction
- * All fields are optional from the protocol's point of view. Each field defaults to value `0` if missing.
- * Note: the first at most 1024 bytes of data MUST be transmitted as part of this message.
- * @start
- * @next EthereumTxRequest
- * @next Failure
- */
-message EthereumSignTx {
-    repeated uint32 address_n = 1;          // BIP-32 path to derive the key from master node
-    optional bytes nonce = 2;               // <=256 bit unsigned big endian
-    optional bytes gas_price = 3;           // <=256 bit unsigned big endian (in wei)
-    optional bytes gas_limit = 4;           // <=256 bit unsigned big endian
-    optional bytes toBin = 5;               // recipient address (20 bytes, legacy firmware)
-    optional string toHex = 11;             // recipient address (hex string, newer firmware)
-    optional bytes value = 6;               // <=256 bit unsigned big endian (in wei)
-    optional bytes data_initial_chunk = 7;  // The initial data chunk (<= 1024 bytes)
-    optional uint32 data_length = 8;        // Length of transaction payload
-    optional uint32 chain_id = 9;           // Chain Id for EIP 155
-    optional uint32 tx_type = 10;           // (only for Wanchain)
-}
-
-/**
- * Response: Device asks for more data from transaction payload, or returns the signature.
- * If data_length is set, device awaits that many more bytes of payload.
- * Otherwise, the signature_* fields contain the computed transaction signature. All three fields will be present.
- * @end
- * @next EthereumTxAck
- */
-message EthereumTxRequest {
-    optional uint32 data_length = 1;    // Number of bytes being requested (<= 1024)
-    optional uint32 signature_v = 2;    // Computed signature (recovery parameter, limited to 27 or 28)
-    optional bytes signature_r = 3;     // Computed signature R component (256 bit)
-    optional bytes signature_s = 4;     // Computed signature S component (256 bit)
-}
-
-/**
- * Request: Transaction payload data.
- * @next EthereumTxRequest
- */
-message EthereumTxAck {
-    optional bytes data_chunk = 1;  // Bytes from transaction payload (<= 1024 bytes)
-}
-
-/**
- * Request: Ask device to sign message
- * @start
- * @next EthereumMessageSignature
- * @next Failure
- */
-message EthereumSignMessage {
-    repeated uint32 address_n = 1;  // BIP-32 path to derive the key from master node
-    optional bytes message = 2;     // message to be signed
-}
-
-/**
- * Response: Signed message
- * @end
- */
-message EthereumMessageSignature {
-    optional bytes addressBin = 1;     // address used to sign the message (20 bytes, legacy firmware)
-    optional bytes signature = 2;      // signature of the message
-    optional string addressHex = 3;    // address used to sign the message (hex string, newer firmware)
-}
-
-/**
- * Request: Ask device to verify message
- * @start
- * @next Success
- * @next Failure
- */
-message EthereumVerifyMessage {
-    optional bytes addressBin = 1;  // address to verify (20 bytes, legacy firmware)
-    optional bytes signature = 2;   // signature to verify
-    optional bytes message = 3;     // message to verify
-    optional string addressHex = 4; // address to verify (hex string, newer firmware)
-}
--- a/accounts/usbwallet/trezor/messages-management.pb.go
+++ b/accounts/usbwallet/trezor/messages-management.pb.go
--- a/accounts/usbwallet/trezor/messages-management.proto
+++ b/accounts/usbwallet/trezor/messages-management.proto
@ -1,289 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages-management.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages.management;
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessageManagement";
-
-import "messages-common.proto";
-
-/**
- * Request: Reset device to default state and ask for device details
- * @start
- * @next Features
- */
-message Initialize {
-    optional bytes state = 1;           // assumed device state, clear session if set and different
-    optional bool skip_passphrase = 2;  // this session should always assume empty passphrase
-}
-
-/**
- * Request: Ask for device details (no device reset)
- * @start
- * @next Features
- */
-message GetFeatures {
-}
-
-/**
- * Response: Reports various information about the device
- * @end
- */
-message Features {
-    optional string vendor = 1;                 // name of the manufacturer, e.g. "trezor.io"
-    optional uint32 major_version = 2;          // major version of the firmware/bootloader, e.g. 1
-    optional uint32 minor_version = 3;          // minor version of the firmware/bootloader, e.g. 0
-    optional uint32 patch_version = 4;          // patch version of the firmware/bootloader, e.g. 0
-    optional bool bootloader_mode = 5;          // is device in bootloader mode?
-    optional string device_id = 6;              // device's unique identifier
-    optional bool pin_protection = 7;           // is device protected by PIN?
-    optional bool passphrase_protection = 8;    // is node/mnemonic encrypted using passphrase?
-    optional string language = 9;               // device language
-    optional string label = 10;                 // device description label
-    optional bool initialized = 12;             // does device contain seed?
-    optional bytes revision = 13;               // SCM revision of firmware
-    optional bytes bootloader_hash = 14;        // hash of the bootloader
-    optional bool imported = 15;                // was storage imported from an external source?
-    optional bool pin_cached = 16;              // is PIN already cached in session?
-    optional bool passphrase_cached = 17;       // is passphrase already cached in session?
-    optional bool firmware_present = 18;        // is valid firmware loaded?
-    optional bool needs_backup = 19;            // does storage need backup? (equals to Storage.needs_backup)
-    optional uint32 flags = 20;                 // device flags (equals to Storage.flags)
-    optional string model = 21;                 // device hardware model
-    optional uint32 fw_major = 22;              // reported firmware version if in bootloader mode
-    optional uint32 fw_minor = 23;              // reported firmware version if in bootloader mode
-    optional uint32 fw_patch = 24;              // reported firmware version if in bootloader mode
-    optional string fw_vendor = 25;             // reported firmware vendor if in bootloader mode
-    optional bytes fw_vendor_keys = 26;         // reported firmware vendor keys (their hash)
-    optional bool unfinished_backup = 27;       // report unfinished backup (equals to Storage.unfinished_backup)
-    optional bool no_backup = 28;               // report no backup (equals to Storage.no_backup)
-}
-
-/**
- * Request: clear session (removes cached PIN, passphrase, etc).
- * @start
- * @next Success
- */
-message ClearSession {
-}
-
-/**
- * Request: change language and/or label of the device
- * @start
- * @next Success
- * @next Failure
- */
-message ApplySettings {
-    optional string language = 1;
-    optional string label = 2;
-    optional bool use_passphrase = 3;
-    optional bytes homescreen = 4;
-    optional PassphraseSourceType passphrase_source = 5;
-    optional uint32 auto_lock_delay_ms = 6;
-    optional uint32 display_rotation = 7;  // in degrees from North
-    /**
-    * Structure representing passphrase source
-    */
-    enum PassphraseSourceType {
-        ASK = 0;
-        DEVICE = 1;
-        HOST = 2;
-    }
-}
-
-/**
- * Request: set flags of the device
- * @start
- * @next Success
- * @next Failure
- */
-message ApplyFlags {
-    optional uint32 flags = 1;  // bitmask, can only set bits, not unset
-}
-
-/**
- * Request: Starts workflow for setting/changing/removing the PIN
- * @start
- * @next Success
- * @next Failure
- */
-message ChangePin {
-    optional bool remove = 1;   // is PIN removal requested?
-}
-
-/**
- * Request: Test if the device is alive, device sends back the message in Success response
- * @start
- * @next Success
- */
-message Ping {
-    optional string message = 1;                // message to send back in Success message
-    optional bool button_protection = 2;        // ask for button press
-    optional bool pin_protection = 3;           // ask for PIN if set in device
-    optional bool passphrase_protection = 4;    // ask for passphrase if set in device
-}
-
-/**
- * Request: Abort last operation that required user interaction
- * @start
- * @next Failure
- */
-message Cancel {
-}
-
-/**
- * Request: Request a sample of random data generated by hardware RNG. May be used for testing.
- * @start
- * @next Entropy
- * @next Failure
- */
-message GetEntropy {
-    required uint32 size = 1;       // size of requested entropy
-}
-
-/**
- * Response: Reply with random data generated by internal RNG
- * @end
- */
-message Entropy {
-    required bytes entropy = 1;     // chunk of random generated bytes
-}
-
-/**
- * Request: Request device to wipe all sensitive data and settings
- * @start
- * @next Success
- * @next Failure
- */
-message WipeDevice {
-}
-
-/**
- * Request: Load seed and related internal settings from the computer
- * @start
- * @next Success
- * @next Failure
- */
-message LoadDevice {
-    optional string mnemonic = 1;                           // seed encoded as BIP-39 mnemonic (12, 18 or 24 words)
-    optional hw.trezor.messages.common.HDNodeType node = 2; // BIP-32 node
-    optional string pin = 3;                                // set PIN protection
-    optional bool passphrase_protection = 4;                // enable master node encryption using passphrase
-    optional string language = 5 [default='english'];       // device language
-    optional string label = 6;                              // device label
-    optional bool skip_checksum = 7;                        // do not test mnemonic for valid BIP-39 checksum
-    optional uint32 u2f_counter = 8;                        // U2F counter
-}
-
-/**
- * Request: Ask device to do initialization involving user interaction
- * @start
- * @next EntropyRequest
- * @next Failure
- */
-message ResetDevice {
-    optional bool display_random = 1;                   // display entropy generated by the device before asking for additional entropy
-    optional uint32 strength = 2 [default=256];         // strength of seed in bits
-    optional bool passphrase_protection = 3;            // enable master node encryption using passphrase
-    optional bool pin_protection = 4;                   // enable PIN protection
-    optional string language = 5 [default='english'];   // device language
-    optional string label = 6;                          // device label
-    optional uint32 u2f_counter = 7;                    // U2F counter
-    optional bool skip_backup = 8;                      // postpone seed backup to BackupDevice workflow
-    optional bool no_backup = 9;                        // indicate that no backup is going to be made
-}
-
-/**
- * Request: Perform backup of the device seed if not backed up using ResetDevice
- * @start
- * @next Success
- */
-message BackupDevice {
-}
-
-/**
- * Response: Ask for additional entropy from host computer
- * @next EntropyAck
- */
-message EntropyRequest {
-}
-
-/**
- * Request: Provide additional entropy for seed generation function
- * @next Success
- */
-message EntropyAck {
-    optional bytes entropy = 1;     // 256 bits (32 bytes) of random data
-}
-
-/**
- * Request: Start recovery workflow asking user for specific words of mnemonic
- * Used to recovery device safely even on untrusted computer.
- * @start
- * @next WordRequest
- */
-message RecoveryDevice {
-    optional uint32 word_count = 1;                     // number of words in BIP-39 mnemonic
-    optional bool passphrase_protection = 2;            // enable master node encryption using passphrase
-    optional bool pin_protection = 3;                   // enable PIN protection
-    optional string language = 4 [default='english'];   // device language
-    optional string label = 5;                          // device label
-    optional bool enforce_wordlist = 6;                 // enforce BIP-39 wordlist during the process
-    // 7 reserved for unused recovery method
-    optional RecoveryDeviceType type = 8;               // supported recovery type
-    optional uint32 u2f_counter = 9;                    // U2F counter
-    optional bool dry_run = 10;                         // perform dry-run recovery workflow (for safe mnemonic validation)
-    /**
-     * Type of recovery procedure. These should be used as bitmask, e.g.,
-     * `RecoveryDeviceType_ScrambledWords | RecoveryDeviceType_Matrix`
-     * listing every method supported by the host computer.
-     *
-     * Note that ScrambledWords must be supported by every implementation
-     * for backward compatibility; there is no way to not support it.
-     */
-    enum RecoveryDeviceType {
-        // use powers of two when extending this field
-        RecoveryDeviceType_ScrambledWords = 0;        // words in scrambled order
-        RecoveryDeviceType_Matrix = 1;                // matrix recovery type
-    }
-}
-
-/**
- * Response: Device is waiting for user to enter word of the mnemonic
- * Its position is shown only on device's internal display.
- * @next WordAck
- */
-message WordRequest {
-    optional WordRequestType type = 1;
-    /**
-    * Type of Recovery Word request
-    */
-    enum WordRequestType {
-        WordRequestType_Plain = 0;
-        WordRequestType_Matrix9 = 1;
-        WordRequestType_Matrix6 = 2;
-    }
-}
-
-/**
- * Request: Computer replies with word from the mnemonic
- * @next WordRequest
- * @next Success
- * @next Failure
- */
-message WordAck {
-    required string word = 1;           // one word of mnemonic on asked position
-}
-
-/**
- * Request: Set U2F counter
- * @start
- * @next Success
- */
-message SetU2FCounter {
-    optional uint32 u2f_counter = 1;    // counter
-}
--- a/accounts/usbwallet/trezor/messages.pb.go
+++ b/accounts/usbwallet/trezor/messages.pb.go
@ -1,889 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: messages.proto
-
-package trezor
-
-import (
-	fmt "fmt"
-	math "math"
-
-	proto "github.com/golang/protobuf/proto"
-	descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
-
-//*
-// Mapping between TREZOR wire identifier (uint) and a protobuf message
-type MessageType int32
-
-const (
-	// Management
-	MessageType_MessageType_Initialize             MessageType = 0
-	MessageType_MessageType_Ping                   MessageType = 1
-	MessageType_MessageType_Success                MessageType = 2
-	MessageType_MessageType_Failure                MessageType = 3
-	MessageType_MessageType_ChangePin              MessageType = 4
-	MessageType_MessageType_WipeDevice             MessageType = 5
-	MessageType_MessageType_GetEntropy             MessageType = 9
-	MessageType_MessageType_Entropy                MessageType = 10
-	MessageType_MessageType_LoadDevice             MessageType = 13
-	MessageType_MessageType_ResetDevice            MessageType = 14
-	MessageType_MessageType_Features               MessageType = 17
-	MessageType_MessageType_PinMatrixRequest       MessageType = 18
-	MessageType_MessageType_PinMatrixAck           MessageType = 19
-	MessageType_MessageType_Cancel                 MessageType = 20
-	MessageType_MessageType_ClearSession           MessageType = 24
-	MessageType_MessageType_ApplySettings          MessageType = 25
-	MessageType_MessageType_ButtonRequest          MessageType = 26
-	MessageType_MessageType_ButtonAck              MessageType = 27
-	MessageType_MessageType_ApplyFlags             MessageType = 28
-	MessageType_MessageType_BackupDevice           MessageType = 34
-	MessageType_MessageType_EntropyRequest         MessageType = 35
-	MessageType_MessageType_EntropyAck             MessageType = 36
-	MessageType_MessageType_PassphraseRequest      MessageType = 41
-	MessageType_MessageType_PassphraseAck          MessageType = 42
-	MessageType_MessageType_PassphraseStateRequest MessageType = 77
-	MessageType_MessageType_PassphraseStateAck     MessageType = 78
-	MessageType_MessageType_RecoveryDevice         MessageType = 45
-	MessageType_MessageType_WordRequest            MessageType = 46
-	MessageType_MessageType_WordAck                MessageType = 47
-	MessageType_MessageType_GetFeatures            MessageType = 55
-	MessageType_MessageType_SetU2FCounter          MessageType = 63
-	// Bootloader
-	MessageType_MessageType_FirmwareErase   MessageType = 6
-	MessageType_MessageType_FirmwareUpload  MessageType = 7
-	MessageType_MessageType_FirmwareRequest MessageType = 8
-	MessageType_MessageType_SelfTest        MessageType = 32
-	// Bitcoin
-	MessageType_MessageType_GetPublicKey     MessageType = 11
-	MessageType_MessageType_PublicKey        MessageType = 12
-	MessageType_MessageType_SignTx           MessageType = 15
-	MessageType_MessageType_TxRequest        MessageType = 21
-	MessageType_MessageType_TxAck            MessageType = 22
-	MessageType_MessageType_GetAddress       MessageType = 29
-	MessageType_MessageType_Address          MessageType = 30
-	MessageType_MessageType_SignMessage      MessageType = 38
-	MessageType_MessageType_VerifyMessage    MessageType = 39
-	MessageType_MessageType_MessageSignature MessageType = 40
-	// Crypto
-	MessageType_MessageType_CipherKeyValue    MessageType = 23
-	MessageType_MessageType_CipheredKeyValue  MessageType = 48
-	MessageType_MessageType_SignIdentity      MessageType = 53
-	MessageType_MessageType_SignedIdentity    MessageType = 54
-	MessageType_MessageType_GetECDHSessionKey MessageType = 61
-	MessageType_MessageType_ECDHSessionKey    MessageType = 62
-	MessageType_MessageType_CosiCommit        MessageType = 71
-	MessageType_MessageType_CosiCommitment    MessageType = 72
-	MessageType_MessageType_CosiSign          MessageType = 73
-	MessageType_MessageType_CosiSignature     MessageType = 74
-	// Debug
-	MessageType_MessageType_DebugLinkDecision    MessageType = 100
-	MessageType_MessageType_DebugLinkGetState    MessageType = 101
-	MessageType_MessageType_DebugLinkState       MessageType = 102
-	MessageType_MessageType_DebugLinkStop        MessageType = 103
-	MessageType_MessageType_DebugLinkLog         MessageType = 104
-	MessageType_MessageType_DebugLinkMemoryRead  MessageType = 110
-	MessageType_MessageType_DebugLinkMemory      MessageType = 111
-	MessageType_MessageType_DebugLinkMemoryWrite MessageType = 112
-	MessageType_MessageType_DebugLinkFlashErase  MessageType = 113
-	// Ethereum
-	MessageType_MessageType_EthereumGetPublicKey     MessageType = 450
-	MessageType_MessageType_EthereumPublicKey        MessageType = 451
-	MessageType_MessageType_EthereumGetAddress       MessageType = 56
-	MessageType_MessageType_EthereumAddress          MessageType = 57
-	MessageType_MessageType_EthereumSignTx           MessageType = 58
-	MessageType_MessageType_EthereumTxRequest        MessageType = 59
-	MessageType_MessageType_EthereumTxAck            MessageType = 60
-	MessageType_MessageType_EthereumSignMessage      MessageType = 64
-	MessageType_MessageType_EthereumVerifyMessage    MessageType = 65
-	MessageType_MessageType_EthereumMessageSignature MessageType = 66
-	// NEM
-	MessageType_MessageType_NEMGetAddress       MessageType = 67
-	MessageType_MessageType_NEMAddress          MessageType = 68
-	MessageType_MessageType_NEMSignTx           MessageType = 69
-	MessageType_MessageType_NEMSignedTx         MessageType = 70
-	MessageType_MessageType_NEMDecryptMessage   MessageType = 75
-	MessageType_MessageType_NEMDecryptedMessage MessageType = 76
-	// Lisk
-	MessageType_MessageType_LiskGetAddress       MessageType = 114
-	MessageType_MessageType_LiskAddress          MessageType = 115
-	MessageType_MessageType_LiskSignTx           MessageType = 116
-	MessageType_MessageType_LiskSignedTx         MessageType = 117
-	MessageType_MessageType_LiskSignMessage      MessageType = 118
-	MessageType_MessageType_LiskMessageSignature MessageType = 119
-	MessageType_MessageType_LiskVerifyMessage    MessageType = 120
-	MessageType_MessageType_LiskGetPublicKey     MessageType = 121
-	MessageType_MessageType_LiskPublicKey        MessageType = 122
-	// Tezos
-	MessageType_MessageType_TezosGetAddress   MessageType = 150
-	MessageType_MessageType_TezosAddress      MessageType = 151
-	MessageType_MessageType_TezosSignTx       MessageType = 152
-	MessageType_MessageType_TezosSignedTx     MessageType = 153
-	MessageType_MessageType_TezosGetPublicKey MessageType = 154
-	MessageType_MessageType_TezosPublicKey    MessageType = 155
-	// Stellar
-	MessageType_MessageType_StellarSignTx               MessageType = 202
-	MessageType_MessageType_StellarTxOpRequest          MessageType = 203
-	MessageType_MessageType_StellarGetAddress           MessageType = 207
-	MessageType_MessageType_StellarAddress              MessageType = 208
-	MessageType_MessageType_StellarCreateAccountOp      MessageType = 210
-	MessageType_MessageType_StellarPaymentOp            MessageType = 211
-	MessageType_MessageType_StellarPathPaymentOp        MessageType = 212
-	MessageType_MessageType_StellarManageOfferOp        MessageType = 213
-	MessageType_MessageType_StellarCreatePassiveOfferOp MessageType = 214
-	MessageType_MessageType_StellarSetOptionsOp         MessageType = 215
-	MessageType_MessageType_StellarChangeTrustOp        MessageType = 216
-	MessageType_MessageType_StellarAllowTrustOp         MessageType = 217
-	MessageType_MessageType_StellarAccountMergeOp       MessageType = 218
-	// omitted: StellarInflationOp is not a supported operation, would be 219
-	MessageType_MessageType_StellarManageDataOp   MessageType = 220
-	MessageType_MessageType_StellarBumpSequenceOp MessageType = 221
-	MessageType_MessageType_StellarSignedTx       MessageType = 230
-	// TRON
-	MessageType_MessageType_TronGetAddress MessageType = 250
-	MessageType_MessageType_TronAddress    MessageType = 251
-	MessageType_MessageType_TronSignTx     MessageType = 252
-	MessageType_MessageType_TronSignedTx   MessageType = 253
-	// Cardano
-	// dropped Sign/VerifyMessage ids 300-302
-	MessageType_MessageType_CardanoSignTx       MessageType = 303
-	MessageType_MessageType_CardanoTxRequest    MessageType = 304
-	MessageType_MessageType_CardanoGetPublicKey MessageType = 305
-	MessageType_MessageType_CardanoPublicKey    MessageType = 306
-	MessageType_MessageType_CardanoGetAddress   MessageType = 307
-	MessageType_MessageType_CardanoAddress      MessageType = 308
-	MessageType_MessageType_CardanoTxAck        MessageType = 309
-	MessageType_MessageType_CardanoSignedTx     MessageType = 310
-	// Ontology
-	MessageType_MessageType_OntologyGetAddress               MessageType = 350
-	MessageType_MessageType_OntologyAddress                  MessageType = 351
-	MessageType_MessageType_OntologyGetPublicKey             MessageType = 352
-	MessageType_MessageType_OntologyPublicKey                MessageType = 353
-	MessageType_MessageType_OntologySignTransfer             MessageType = 354
-	MessageType_MessageType_OntologySignedTransfer           MessageType = 355
-	MessageType_MessageType_OntologySignWithdrawOng          MessageType = 356
-	MessageType_MessageType_OntologySignedWithdrawOng        MessageType = 357
-	MessageType_MessageType_OntologySignOntIdRegister        MessageType = 358
-	MessageType_MessageType_OntologySignedOntIdRegister      MessageType = 359
-	MessageType_MessageType_OntologySignOntIdAddAttributes   MessageType = 360
-	MessageType_MessageType_OntologySignedOntIdAddAttributes MessageType = 361
-	// Ripple
-	MessageType_MessageType_RippleGetAddress MessageType = 400
-	MessageType_MessageType_RippleAddress    MessageType = 401
-	MessageType_MessageType_RippleSignTx     MessageType = 402
-	MessageType_MessageType_RippleSignedTx   MessageType = 403
-	// Monero
-	MessageType_MessageType_MoneroTransactionInitRequest              MessageType = 501
-	MessageType_MessageType_MoneroTransactionInitAck                  MessageType = 502
-	MessageType_MessageType_MoneroTransactionSetInputRequest          MessageType = 503
-	MessageType_MessageType_MoneroTransactionSetInputAck              MessageType = 504
-	MessageType_MessageType_MoneroTransactionInputsPermutationRequest MessageType = 505
-	MessageType_MessageType_MoneroTransactionInputsPermutationAck     MessageType = 506
-	MessageType_MessageType_MoneroTransactionInputViniRequest         MessageType = 507
-	MessageType_MessageType_MoneroTransactionInputViniAck             MessageType = 508
-	MessageType_MessageType_MoneroTransactionAllInputsSetRequest      MessageType = 509
-	MessageType_MessageType_MoneroTransactionAllInputsSetAck          MessageType = 510
-	MessageType_MessageType_MoneroTransactionSetOutputRequest         MessageType = 511
-	MessageType_MessageType_MoneroTransactionSetOutputAck             MessageType = 512
-	MessageType_MessageType_MoneroTransactionAllOutSetRequest         MessageType = 513
-	MessageType_MessageType_MoneroTransactionAllOutSetAck             MessageType = 514
-	MessageType_MessageType_MoneroTransactionSignInputRequest         MessageType = 515
-	MessageType_MessageType_MoneroTransactionSignInputAck             MessageType = 516
-	MessageType_MessageType_MoneroTransactionFinalRequest             MessageType = 517
-	MessageType_MessageType_MoneroTransactionFinalAck                 MessageType = 518
-	MessageType_MessageType_MoneroKeyImageExportInitRequest           MessageType = 530
-	MessageType_MessageType_MoneroKeyImageExportInitAck               MessageType = 531
-	MessageType_MessageType_MoneroKeyImageSyncStepRequest             MessageType = 532
-	MessageType_MessageType_MoneroKeyImageSyncStepAck                 MessageType = 533
-	MessageType_MessageType_MoneroKeyImageSyncFinalRequest            MessageType = 534
-	MessageType_MessageType_MoneroKeyImageSyncFinalAck                MessageType = 535
-	MessageType_MessageType_MoneroGetAddress                          MessageType = 540
-	MessageType_MessageType_MoneroAddress                             MessageType = 541
-	MessageType_MessageType_MoneroGetWatchKey                         MessageType = 542
-	MessageType_MessageType_MoneroWatchKey                            MessageType = 543
-	MessageType_MessageType_DebugMoneroDiagRequest                    MessageType = 546
-	MessageType_MessageType_DebugMoneroDiagAck                        MessageType = 547
-	MessageType_MessageType_MoneroGetTxKeyRequest                     MessageType = 550
-	MessageType_MessageType_MoneroGetTxKeyAck                         MessageType = 551
-	MessageType_MessageType_MoneroLiveRefreshStartRequest             MessageType = 552
-	MessageType_MessageType_MoneroLiveRefreshStartAck                 MessageType = 553
-	MessageType_MessageType_MoneroLiveRefreshStepRequest              MessageType = 554
-	MessageType_MessageType_MoneroLiveRefreshStepAck                  MessageType = 555
-	MessageType_MessageType_MoneroLiveRefreshFinalRequest             MessageType = 556
-	MessageType_MessageType_MoneroLiveRefreshFinalAck                 MessageType = 557
-	// EOS
-	MessageType_MessageType_EosGetPublicKey    MessageType = 600
-	MessageType_MessageType_EosPublicKey       MessageType = 601
-	MessageType_MessageType_EosSignTx          MessageType = 602
-	MessageType_MessageType_EosTxActionRequest MessageType = 603
-	MessageType_MessageType_EosTxActionAck     MessageType = 604
-	MessageType_MessageType_EosSignedTx        MessageType = 605
-	// Binance
-	MessageType_MessageType_BinanceGetAddress   MessageType = 700
-	MessageType_MessageType_BinanceAddress      MessageType = 701
-	MessageType_MessageType_BinanceGetPublicKey MessageType = 702
-	MessageType_MessageType_BinancePublicKey    MessageType = 703
-	MessageType_MessageType_BinanceSignTx       MessageType = 704
-	MessageType_MessageType_BinanceTxRequest    MessageType = 705
-	MessageType_MessageType_BinanceTransferMsg  MessageType = 706
-	MessageType_MessageType_BinanceOrderMsg     MessageType = 707
-	MessageType_MessageType_BinanceCancelMsg    MessageType = 708
-	MessageType_MessageType_BinanceSignedTx     MessageType = 709
-)
-
-var MessageType_name = map[int32]string{
-	0:   "MessageType_Initialize",
-	1:   "MessageType_Ping",
-	2:   "MessageType_Success",
-	3:   "MessageType_Failure",
-	4:   "MessageType_ChangePin",
-	5:   "MessageType_WipeDevice",
-	9:   "MessageType_GetEntropy",
-	10:  "MessageType_Entropy",
-	13:  "MessageType_LoadDevice",
-	14:  "MessageType_ResetDevice",
-	17:  "MessageType_Features",
-	18:  "MessageType_PinMatrixRequest",
-	19:  "MessageType_PinMatrixAck",
-	20:  "MessageType_Cancel",
-	24:  "MessageType_ClearSession",
-	25:  "MessageType_ApplySettings",
-	26:  "MessageType_ButtonRequest",
-	27:  "MessageType_ButtonAck",
-	28:  "MessageType_ApplyFlags",
-	34:  "MessageType_BackupDevice",
-	35:  "MessageType_EntropyRequest",
-	36:  "MessageType_EntropyAck",
-	41:  "MessageType_PassphraseRequest",
-	42:  "MessageType_PassphraseAck",
-	77:  "MessageType_PassphraseStateRequest",
-	78:  "MessageType_PassphraseStateAck",
-	45:  "MessageType_RecoveryDevice",
-	46:  "MessageType_WordRequest",
-	47:  "MessageType_WordAck",
-	55:  "MessageType_GetFeatures",
-	63:  "MessageType_SetU2FCounter",
-	6:   "MessageType_FirmwareErase",
-	7:   "MessageType_FirmwareUpload",
-	8:   "MessageType_FirmwareRequest",
-	32:  "MessageType_SelfTest",
-	11:  "MessageType_GetPublicKey",
-	12:  "MessageType_PublicKey",
-	15:  "MessageType_SignTx",
-	21:  "MessageType_TxRequest",
-	22:  "MessageType_TxAck",
-	29:  "MessageType_GetAddress",
-	30:  "MessageType_Address",
-	38:  "MessageType_SignMessage",
-	39:  "MessageType_VerifyMessage",
-	40:  "MessageType_MessageSignature",
-	23:  "MessageType_CipherKeyValue",
-	48:  "MessageType_CipheredKeyValue",
-	53:  "MessageType_SignIdentity",
-	54:  "MessageType_SignedIdentity",
-	61:  "MessageType_GetECDHSessionKey",
-	62:  "MessageType_ECDHSessionKey",
-	71:  "MessageType_CosiCommit",
-	72:  "MessageType_CosiCommitment",
-	73:  "MessageType_CosiSign",
-	74:  "MessageType_CosiSignature",
-	100: "MessageType_DebugLinkDecision",
-	101: "MessageType_DebugLinkGetState",
-	102: "MessageType_DebugLinkState",
-	103: "MessageType_DebugLinkStop",
-	104: "MessageType_DebugLinkLog",
-	110: "MessageType_DebugLinkMemoryRead",
-	111: "MessageType_DebugLinkMemory",
-	112: "MessageType_DebugLinkMemoryWrite",
-	113: "MessageType_DebugLinkFlashErase",
-	450: "MessageType_EthereumGetPublicKey",
-	451: "MessageType_EthereumPublicKey",
-	56:  "MessageType_EthereumGetAddress",
-	57:  "MessageType_EthereumAddress",
-	58:  "MessageType_EthereumSignTx",
-	59:  "MessageType_EthereumTxRequest",
-	60:  "MessageType_EthereumTxAck",
-	64:  "MessageType_EthereumSignMessage",
-	65:  "MessageType_EthereumVerifyMessage",
-	66:  "MessageType_EthereumMessageSignature",
-	67:  "MessageType_NEMGetAddress",
-	68:  "MessageType_NEMAddress",
-	69:  "MessageType_NEMSignTx",
-	70:  "MessageType_NEMSignedTx",
-	75:  "MessageType_NEMDecryptMessage",
-	76:  "MessageType_NEMDecryptedMessage",
-	114: "MessageType_LiskGetAddress",
-	115: "MessageType_LiskAddress",
-	116: "MessageType_LiskSignTx",
-	117: "MessageType_LiskSignedTx",
-	118: "MessageType_LiskSignMessage",
-	119: "MessageType_LiskMessageSignature",
-	120: "MessageType_LiskVerifyMessage",
-	121: "MessageType_LiskGetPublicKey",
-	122: "MessageType_LiskPublicKey",
-	150: "MessageType_TezosGetAddress",
-	151: "MessageType_TezosAddress",
-	152: "MessageType_TezosSignTx",
-	153: "MessageType_TezosSignedTx",
-	154: "MessageType_TezosGetPublicKey",
-	155: "MessageType_TezosPublicKey",
-	202: "MessageType_StellarSignTx",
-	203: "MessageType_StellarTxOpRequest",
-	207: "MessageType_StellarGetAddress",
-	208: "MessageType_StellarAddress",
-	210: "MessageType_StellarCreateAccountOp",
-	211: "MessageType_StellarPaymentOp",
-	212: "MessageType_StellarPathPaymentOp",
-	213: "MessageType_StellarManageOfferOp",
-	214: "MessageType_StellarCreatePassiveOfferOp",
-	215: "MessageType_StellarSetOptionsOp",
-	216: "MessageType_StellarChangeTrustOp",
-	217: "MessageType_StellarAllowTrustOp",
-	218: "MessageType_StellarAccountMergeOp",
-	220: "MessageType_StellarManageDataOp",
-	221: "MessageType_StellarBumpSequenceOp",
-	230: "MessageType_StellarSignedTx",
-	250: "MessageType_TronGetAddress",
-	251: "MessageType_TronAddress",
-	252: "MessageType_TronSignTx",
-	253: "MessageType_TronSignedTx",
-	303: "MessageType_CardanoSignTx",
-	304: "MessageType_CardanoTxRequest",
-	305: "MessageType_CardanoGetPublicKey",
-	306: "MessageType_CardanoPublicKey",
-	307: "MessageType_CardanoGetAddress",
-	308: "MessageType_CardanoAddress",
-	309: "MessageType_CardanoTxAck",
-	310: "MessageType_CardanoSignedTx",
-	350: "MessageType_OntologyGetAddress",
-	351: "MessageType_OntologyAddress",
-	352: "MessageType_OntologyGetPublicKey",
-	353: "MessageType_OntologyPublicKey",
-	354: "MessageType_OntologySignTransfer",
-	355: "MessageType_OntologySignedTransfer",
-	356: "MessageType_OntologySignWithdrawOng",
-	357: "MessageType_OntologySignedWithdrawOng",
-	358: "MessageType_OntologySignOntIdRegister",
-	359: "MessageType_OntologySignedOntIdRegister",
-	360: "MessageType_OntologySignOntIdAddAttributes",
-	361: "MessageType_OntologySignedOntIdAddAttributes",
-	400: "MessageType_RippleGetAddress",
-	401: "MessageType_RippleAddress",
-	402: "MessageType_RippleSignTx",
-	403: "MessageType_RippleSignedTx",
-	501: "MessageType_MoneroTransactionInitRequest",
-	502: "MessageType_MoneroTransactionInitAck",
-	503: "MessageType_MoneroTransactionSetInputRequest",
-	504: "MessageType_MoneroTransactionSetInputAck",
-	505: "MessageType_MoneroTransactionInputsPermutationRequest",
-	506: "MessageType_MoneroTransactionInputsPermutationAck",
-	507: "MessageType_MoneroTransactionInputViniRequest",
-	508: "MessageType_MoneroTransactionInputViniAck",
-	509: "MessageType_MoneroTransactionAllInputsSetRequest",
-	510: "MessageType_MoneroTransactionAllInputsSetAck",
-	511: "MessageType_MoneroTransactionSetOutputRequest",
-	512: "MessageType_MoneroTransactionSetOutputAck",
-	513: "MessageType_MoneroTransactionAllOutSetRequest",
-	514: "MessageType_MoneroTransactionAllOutSetAck",
-	515: "MessageType_MoneroTransactionSignInputRequest",
-	516: "MessageType_MoneroTransactionSignInputAck",
-	517: "MessageType_MoneroTransactionFinalRequest",
-	518: "MessageType_MoneroTransactionFinalAck",
-	530: "MessageType_MoneroKeyImageExportInitRequest",
-	531: "MessageType_MoneroKeyImageExportInitAck",
-	532: "MessageType_MoneroKeyImageSyncStepRequest",
-	533: "MessageType_MoneroKeyImageSyncStepAck",
-	534: "MessageType_MoneroKeyImageSyncFinalRequest",
-	535: "MessageType_MoneroKeyImageSyncFinalAck",
-	540: "MessageType_MoneroGetAddress",
-	541: "MessageType_MoneroAddress",
-	542: "MessageType_MoneroGetWatchKey",
-	543: "MessageType_MoneroWatchKey",
-	546: "MessageType_DebugMoneroDiagRequest",
-	547: "MessageType_DebugMoneroDiagAck",
-	550: "MessageType_MoneroGetTxKeyRequest",
-	551: "MessageType_MoneroGetTxKeyAck",
-	552: "MessageType_MoneroLiveRefreshStartRequest",
-	553: "MessageType_MoneroLiveRefreshStartAck",
-	554: "MessageType_MoneroLiveRefreshStepRequest",
-	555: "MessageType_MoneroLiveRefreshStepAck",
-	556: "MessageType_MoneroLiveRefreshFinalRequest",
-	557: "MessageType_MoneroLiveRefreshFinalAck",
-	600: "MessageType_EosGetPublicKey",
-	601: "MessageType_EosPublicKey",
-	602: "MessageType_EosSignTx",
-	603: "MessageType_EosTxActionRequest",
-	604: "MessageType_EosTxActionAck",
-	605: "MessageType_EosSignedTx",
-	700: "MessageType_BinanceGetAddress",
-	701: "MessageType_BinanceAddress",
-	702: "MessageType_BinanceGetPublicKey",
-	703: "MessageType_BinancePublicKey",
-	704: "MessageType_BinanceSignTx",
-	705: "MessageType_BinanceTxRequest",
-	706: "MessageType_BinanceTransferMsg",
-	707: "MessageType_BinanceOrderMsg",
-	708: "MessageType_BinanceCancelMsg",
-	709: "MessageType_BinanceSignedTx",
-}
-
-var MessageType_value = map[string]int32{
-	"MessageType_Initialize":                                0,
-	"MessageType_Ping":                                      1,
-	"MessageType_Success":                                   2,
-	"MessageType_Failure":                                   3,
-	"MessageType_ChangePin":                                 4,
-	"MessageType_WipeDevice":                                5,
-	"MessageType_GetEntropy":                                9,
-	"MessageType_Entropy":                                   10,
-	"MessageType_LoadDevice":                                13,
-	"MessageType_ResetDevice":                               14,
-	"MessageType_Features":                                  17,
-	"MessageType_PinMatrixRequest":                          18,
-	"MessageType_PinMatrixAck":                              19,
-	"MessageType_Cancel":                                    20,
-	"MessageType_ClearSession":                              24,
-	"MessageType_ApplySettings":                             25,
-	"MessageType_ButtonRequest":                             26,
-	"MessageType_ButtonAck":                                 27,
-	"MessageType_ApplyFlags":                                28,
-	"MessageType_BackupDevice":                              34,
-	"MessageType_EntropyRequest":                            35,
-	"MessageType_EntropyAck":                                36,
-	"MessageType_PassphraseRequest":                         41,
-	"MessageType_PassphraseAck":                             42,
-	"MessageType_PassphraseStateRequest":                    77,
-	"MessageType_PassphraseStateAck":                        78,
-	"MessageType_RecoveryDevice":                            45,
-	"MessageType_WordRequest":                               46,
-	"MessageType_WordAck":                                   47,
-	"MessageType_GetFeatures":                               55,
-	"MessageType_SetU2FCounter":                             63,
-	"MessageType_FirmwareErase":                             6,
-	"MessageType_FirmwareUpload":                            7,
-	"MessageType_FirmwareRequest":                           8,
-	"MessageType_SelfTest":                                  32,
-	"MessageType_GetPublicKey":                              11,
-	"MessageType_PublicKey":                                 12,
-	"MessageType_SignTx":                                    15,
-	"MessageType_TxRequest":                                 21,
-	"MessageType_TxAck":                                     22,
-	"MessageType_GetAddress":                                29,
-	"MessageType_Address":                                   30,
-	"MessageType_SignMessage":                               38,
-	"MessageType_VerifyMessage":                             39,
-	"MessageType_MessageSignature":                          40,
-	"MessageType_CipherKeyValue":                            23,
-	"MessageType_CipheredKeyValue":                          48,
-	"MessageType_SignIdentity":                              53,
-	"MessageType_SignedIdentity":                            54,
-	"MessageType_GetECDHSessionKey":                         61,
-	"MessageType_ECDHSessionKey":                            62,
-	"MessageType_CosiCommit":                                71,
-	"MessageType_CosiCommitment":                            72,
-	"MessageType_CosiSign":                                  73,
-	"MessageType_CosiSignature":                             74,
-	"MessageType_DebugLinkDecision":                         100,
-	"MessageType_DebugLinkGetState":                         101,
-	"MessageType_DebugLinkState":                            102,
-	"MessageType_DebugLinkStop":                             103,
-	"MessageType_DebugLinkLog":                              104,
-	"MessageType_DebugLinkMemoryRead":                       110,
-	"MessageType_DebugLinkMemory":                           111,
-	"MessageType_DebugLinkMemoryWrite":                      112,
-	"MessageType_DebugLinkFlashErase":                       113,
-	"MessageType_EthereumGetPublicKey":                      450,
-	"MessageType_EthereumPublicKey":                         451,
-	"MessageType_EthereumGetAddress":                        56,
-	"MessageType_EthereumAddress":                           57,
-	"MessageType_EthereumSignTx":                            58,
-	"MessageType_EthereumTxRequest":                         59,
-	"MessageType_EthereumTxAck":                             60,
-	"MessageType_EthereumSignMessage":                       64,
-	"MessageType_EthereumVerifyMessage":                     65,
-	"MessageType_EthereumMessageSignature":                  66,
-	"MessageType_NEMGetAddress":                             67,
-	"MessageType_NEMAddress":                                68,
-	"MessageType_NEMSignTx":                                 69,
-	"MessageType_NEMSignedTx":                               70,
-	"MessageType_NEMDecryptMessage":                         75,
-	"MessageType_NEMDecryptedMessage":                       76,
-	"MessageType_LiskGetAddress":                            114,
-	"MessageType_LiskAddress":                               115,
-	"MessageType_LiskSignTx":                                116,
-	"MessageType_LiskSignedTx":                              117,
-	"MessageType_LiskSignMessage":                           118,
-	"MessageType_LiskMessageSignature":                      119,
-	"MessageType_LiskVerifyMessage":                         120,
-	"MessageType_LiskGetPublicKey":                          121,
-	"MessageType_LiskPublicKey":                             122,
-	"MessageType_TezosGetAddress":                           150,
-	"MessageType_TezosAddress":                              151,
-	"MessageType_TezosSignTx":                               152,
-	"MessageType_TezosSignedTx":                             153,
-	"MessageType_TezosGetPublicKey":                         154,
-	"MessageType_TezosPublicKey":                            155,
-	"MessageType_StellarSignTx":                             202,
-	"MessageType_StellarTxOpRequest":                        203,
-	"MessageType_StellarGetAddress":                         207,
-	"MessageType_StellarAddress":                            208,
-	"MessageType_StellarCreateAccountOp":                    210,
-	"MessageType_StellarPaymentOp":                          211,
-	"MessageType_StellarPathPaymentOp":                      212,
-	"MessageType_StellarManageOfferOp":                      213,
-	"MessageType_StellarCreatePassiveOfferOp":               214,
-	"MessageType_StellarSetOptionsOp":                       215,
-	"MessageType_StellarChangeTrustOp":                      216,
-	"MessageType_StellarAllowTrustOp":                       217,
-	"MessageType_StellarAccountMergeOp":                     218,
-	"MessageType_StellarManageDataOp":                       220,
-	"MessageType_StellarBumpSequenceOp":                     221,
-	"MessageType_StellarSignedTx":                           230,
-	"MessageType_TronGetAddress":                            250,
-	"MessageType_TronAddress":                               251,
-	"MessageType_TronSignTx":                                252,
-	"MessageType_TronSignedTx":                              253,
-	"MessageType_CardanoSignTx":                             303,
-	"MessageType_CardanoTxRequest":                          304,
-	"MessageType_CardanoGetPublicKey":                       305,
-	"MessageType_CardanoPublicKey":                          306,
-	"MessageType_CardanoGetAddress":                         307,
-	"MessageType_CardanoAddress":                            308,
-	"MessageType_CardanoTxAck":                              309,
-	"MessageType_CardanoSignedTx":                           310,
-	"MessageType_OntologyGetAddress":                        350,
-	"MessageType_OntologyAddress":                           351,
-	"MessageType_OntologyGetPublicKey":                      352,
-	"MessageType_OntologyPublicKey":                         353,
-	"MessageType_OntologySignTransfer":                      354,
-	"MessageType_OntologySignedTransfer":                    355,
-	"MessageType_OntologySignWithdrawOng":                   356,
-	"MessageType_OntologySignedWithdrawOng":                 357,
-	"MessageType_OntologySignOntIdRegister":                 358,
-	"MessageType_OntologySignedOntIdRegister":               359,
-	"MessageType_OntologySignOntIdAddAttributes":            360,
-	"MessageType_OntologySignedOntIdAddAttributes":          361,
-	"MessageType_RippleGetAddress":                          400,
-	"MessageType_RippleAddress":                             401,
-	"MessageType_RippleSignTx":                              402,
-	"MessageType_RippleSignedTx":                            403,
-	"MessageType_MoneroTransactionInitRequest":              501,
-	"MessageType_MoneroTransactionInitAck":                  502,
-	"MessageType_MoneroTransactionSetInputRequest":          503,
-	"MessageType_MoneroTransactionSetInputAck":              504,
-	"MessageType_MoneroTransactionInputsPermutationRequest": 505,
-	"MessageType_MoneroTransactionInputsPermutationAck":     506,
-	"MessageType_MoneroTransactionInputViniRequest":         507,
-	"MessageType_MoneroTransactionInputViniAck":             508,
-	"MessageType_MoneroTransactionAllInputsSetRequest":      509,
-	"MessageType_MoneroTransactionAllInputsSetAck":          510,
-	"MessageType_MoneroTransactionSetOutputRequest":         511,
-	"MessageType_MoneroTransactionSetOutputAck":             512,
-	"MessageType_MoneroTransactionAllOutSetRequest":         513,
-	"MessageType_MoneroTransactionAllOutSetAck":             514,
-	"MessageType_MoneroTransactionSignInputRequest":         515,
-	"MessageType_MoneroTransactionSignInputAck":             516,
-	"MessageType_MoneroTransactionFinalRequest":             517,
-	"MessageType_MoneroTransactionFinalAck":                 518,
-	"MessageType_MoneroKeyImageExportInitRequest":           530,
-	"MessageType_MoneroKeyImageExportInitAck":               531,
-	"MessageType_MoneroKeyImageSyncStepRequest":             532,
-	"MessageType_MoneroKeyImageSyncStepAck":                 533,
-	"MessageType_MoneroKeyImageSyncFinalRequest":            534,
-	"MessageType_MoneroKeyImageSyncFinalAck":                535,
-	"MessageType_MoneroGetAddress":                          540,
-	"MessageType_MoneroAddress":                             541,
-	"MessageType_MoneroGetWatchKey":                         542,
-	"MessageType_MoneroWatchKey":                            543,
-	"MessageType_DebugMoneroDiagRequest":                    546,
-	"MessageType_DebugMoneroDiagAck":                        547,
-	"MessageType_MoneroGetTxKeyRequest":                     550,
-	"MessageType_MoneroGetTxKeyAck":                         551,
-	"MessageType_MoneroLiveRefreshStartRequest":             552,
-	"MessageType_MoneroLiveRefreshStartAck":                 553,
-	"MessageType_MoneroLiveRefreshStepRequest":              554,
-	"MessageType_MoneroLiveRefreshStepAck":                  555,
-	"MessageType_MoneroLiveRefreshFinalRequest":             556,
-	"MessageType_MoneroLiveRefreshFinalAck":                 557,
-	"MessageType_EosGetPublicKey":                           600,
-	"MessageType_EosPublicKey":                              601,
-	"MessageType_EosSignTx":                                 602,
-	"MessageType_EosTxActionRequest":                        603,
-	"MessageType_EosTxActionAck":                            604,
-	"MessageType_EosSignedTx":                               605,
-	"MessageType_BinanceGetAddress":                         700,
-	"MessageType_BinanceAddress":                            701,
-	"MessageType_BinanceGetPublicKey":                       702,
-	"MessageType_BinancePublicKey":                          703,
-	"MessageType_BinanceSignTx":                             704,
-	"MessageType_BinanceTxRequest":                          705,
-	"MessageType_BinanceTransferMsg":                        706,
-	"MessageType_BinanceOrderMsg":                           707,
-	"MessageType_BinanceCancelMsg":                          708,
-	"MessageType_BinanceSignedTx":                           709,
-}
-
-func (x MessageType) Enum() *MessageType {
-	p := new(MessageType)
-	*p = x
-	return p
-}
-
-func (x MessageType) String() string {
-	return proto.EnumName(MessageType_name, int32(x))
-}
-
-func (x *MessageType) UnmarshalJSON(data []byte) error {
-	value, err := proto.UnmarshalJSONEnum(MessageType_value, data, "MessageType")
-	if err != nil {
-		return err
-	}
-	*x = MessageType(value)
-	return nil
-}
-
-func (MessageType) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_4dc296cbfe5ffcd5, []int{0}
-}
-
-var E_WireIn = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50002,
-	Name:          "hw.trezor.messages.wire_in",
-	Tag:           "varint,50002,opt,name=wire_in",
-	Filename:      "messages.proto",
-}
-
-var E_WireOut = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50003,
-	Name:          "hw.trezor.messages.wire_out",
-	Tag:           "varint,50003,opt,name=wire_out",
-	Filename:      "messages.proto",
-}
-
-var E_WireDebugIn = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50004,
-	Name:          "hw.trezor.messages.wire_debug_in",
-	Tag:           "varint,50004,opt,name=wire_debug_in",
-	Filename:      "messages.proto",
-}
-
-var E_WireDebugOut = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50005,
-	Name:          "hw.trezor.messages.wire_debug_out",
-	Tag:           "varint,50005,opt,name=wire_debug_out",
-	Filename:      "messages.proto",
-}
-
-var E_WireTiny = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50006,
-	Name:          "hw.trezor.messages.wire_tiny",
-	Tag:           "varint,50006,opt,name=wire_tiny",
-	Filename:      "messages.proto",
-}
-
-var E_WireBootloader = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50007,
-	Name:          "hw.trezor.messages.wire_bootloader",
-	Tag:           "varint,50007,opt,name=wire_bootloader",
-	Filename:      "messages.proto",
-}
-
-var E_WireNoFsm = &proto.ExtensionDesc{
-	ExtendedType:  (*descriptor.EnumValueOptions)(nil),
-	ExtensionType: (*bool)(nil),
-	Field:         50008,
-	Name:          "hw.trezor.messages.wire_no_fsm",
-	Tag:           "varint,50008,opt,name=wire_no_fsm",
-	Filename:      "messages.proto",
-}
-
-func init() {
-	proto.RegisterEnum("hw.trezor.messages.MessageType", MessageType_name, MessageType_value)
-	proto.RegisterExtension(E_WireIn)
-	proto.RegisterExtension(E_WireOut)
-	proto.RegisterExtension(E_WireDebugIn)
-	proto.RegisterExtension(E_WireDebugOut)
-	proto.RegisterExtension(E_WireTiny)
-	proto.RegisterExtension(E_WireBootloader)
-	proto.RegisterExtension(E_WireNoFsm)
-}
-
-func init() { proto.RegisterFile("messages.proto", fileDescriptor_4dc296cbfe5ffcd5) }
-
-var fileDescriptor_4dc296cbfe5ffcd5 = []byte{
-	// 2430 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x9a, 0xd9, 0x73, 0x1c, 0xc5,
-	0x1d, 0xc7, 0xb3, 0xab, 0x11, 0x88, 0xf6, 0x41, 0x23, 0xb0, 0x2d, 0xaf, 0x2f, 0xf9, 0xc0, 0x96,
-	0x2f, 0xd9, 0x10, 0x0c, 0x44, 0x38, 0x60, 0x69, 0xb5, 0x12, 0x8a, 0xb5, 0x5a, 0x97, 0x76, 0xb1,
-	0x1f, 0x5d, 0xa3, 0x9d, 0xd6, 0x6e, 0x97, 0x67, 0x67, 0x86, 0x9e, 0x1e, 0x49, 0xeb, 0xa7, 0x9c,
-	0x3c, 0x13, 0x48, 0xc0, 0xb9, 0xa9, 0xa4, 0x2a, 0x21, 0x57, 0x85, 0x1c, 0x4e, 0x25, 0x55, 0x39,
-	0x08, 0x24, 0x2f, 0xc9, 0x43, 0x52, 0x9c, 0x86, 0x40, 0xee, 0x90, 0xe4, 0x0f, 0xc8, 0xc5, 0x91,
-	0xa4, 0x7a, 0xa6, 0xbb, 0xe7, 0xd8, 0xdf, 0xae, 0x36, 0x6f, 0x58, 0xf3, 0xf9, 0x7d, 0x7f, 0x47,
-	0xff, 0xfa, 0x37, 0xdd, 0xb3, 0xa0, 0xcd, 0x2d, 0xe2, 0xfb, 0x66, 0x83, 0xf8, 0xe3, 0x1e, 0x73,
-	0xb9, 0x3b, 0x3c, 0xdc, 0x5c, 0x1d, 0xe7, 0x8c, 0x5c, 0x76, 0xd9, 0xb8, 0x7a, 0x52, 0x18, 0x6d,
-	0xb8, 0x6e, 0xc3, 0x26, 0x27, 0x42, 0x62, 0x29, 0x58, 0x3e, 0x61, 0x11, 0xbf, 0xce, 0xa8, 0xc7,
-	0x5d, 0x16, 0x59, 0x1d, 0xf9, 0xfe, 0x7d, 0x68, 0x43, 0x39, 0xc2, 0x6b, 0x6d, 0x8f, 0x0c, 0x1f,
-	0x40, 0x5b, 0x13, 0xff, 0xbc, 0x38, 0xe7, 0x50, 0x4e, 0x4d, 0x9b, 0x5e, 0x26, 0xf8, 0x5d, 0x85,
-	0xa1, 0x87, 0xaf, 0x8e, 0xe4, 0x9e, 0xba, 0x3a, 0x92, 0x1b, 0x2e, 0x20, 0x9c, 0xa4, 0xce, 0x51,
-	0xa7, 0x81, 0x73, 0x05, 0x43, 0x3c, 0x1f, 0xde, 0x85, 0x6e, 0x4e, 0x3e, 0xab, 0x06, 0xf5, 0x3a,
-	0xf1, 0x7d, 0x9c, 0x2f, 0x18, 0x57, 0x80, 0xc7, 0x33, 0x26, 0xb5, 0x03, 0x46, 0xf0, 0x80, 0x7c,
-	0xbc, 0x07, 0x6d, 0x49, 0x3e, 0x2e, 0x36, 0x4d, 0xa7, 0x41, 0xce, 0x51, 0x07, 0x1b, 0x52, 0x7e,
-	0x34, 0x1d, 0xe0, 0x05, 0xea, 0x91, 0x69, 0xb2, 0x42, 0xeb, 0x04, 0x0f, 0xc2, 0xc4, 0x2c, 0xe1,
-	0x25, 0x87, 0x33, 0xd7, 0x6b, 0xe3, 0x1b, 0xe0, 0x10, 0xd5, 0x63, 0x24, 0x63, 0xc8, 0x08, 0xcc,
-	0xbb, 0xa6, 0x25, 0x5d, 0x6c, 0x92, 0x02, 0x7b, 0xd1, 0xb6, 0x24, 0xb1, 0x48, 0x7c, 0xc2, 0x25,
-	0xb2, 0x59, 0x22, 0xbb, 0xd1, 0x2d, 0xa9, 0x3c, 0x89, 0xc9, 0x03, 0x46, 0x7c, 0x7c, 0x93, 0x74,
-	0x72, 0x10, 0xed, 0xcc, 0x94, 0xb0, 0x6c, 0x72, 0x46, 0xd7, 0x16, 0xc9, 0x83, 0x01, 0xf1, 0x39,
-	0x1e, 0x96, 0xdc, 0x11, 0x34, 0x02, 0x72, 0x93, 0xf5, 0x4b, 0xf8, 0xe6, 0xc2, 0x46, 0xb5, 0x24,
-	0x4f, 0x47, 0x81, 0x0f, 0xa7, 0x8a, 0x67, 0x3a, 0x75, 0x62, 0xe3, 0x5b, 0x12, 0x0b, 0xb7, 0x2f,
-	0xad, 0x56, 0xb4, 0x89, 0xc9, 0xaa, 0xc4, 0xf7, 0xa9, 0xeb, 0xe0, 0x11, 0x19, 0xf9, 0x7e, 0xb4,
-	0x3d, 0xc9, 0x4c, 0x7a, 0x9e, 0xdd, 0xae, 0x12, 0xce, 0xa9, 0xd3, 0xf0, 0xf1, 0x76, 0x18, 0x9a,
-	0x0a, 0x38, 0x77, 0x1d, 0x15, 0x7b, 0x41, 0xc6, 0x7e, 0x28, 0xbd, 0x98, 0x11, 0x24, 0x02, 0xdf,
-	0xd1, 0x11, 0xf8, 0xd6, 0x0e, 0x97, 0x33, 0xb6, 0xd9, 0xf0, 0xf1, 0x4e, 0xe9, 0x2f, 0x13, 0xf8,
-	0x94, 0x59, 0xbf, 0x14, 0x78, 0xb2, 0xe4, 0xfb, 0x24, 0x73, 0x00, 0x15, 0x80, 0x65, 0x55, 0x41,
-	0xed, 0x87, 0x57, 0x57, 0x52, 0x22, 0xaa, 0x03, 0x52, 0xe7, 0x10, 0xda, 0x95, 0x2a, 0xb9, 0xe9,
-	0xfb, 0x5e, 0x93, 0x99, 0x3e, 0x51, 0x52, 0x87, 0xa5, 0xd4, 0xd1, 0x74, 0x11, 0x62, 0x50, 0xa8,
-	0x1d, 0xc9, 0xe4, 0x78, 0x0c, 0xed, 0x83, 0xe1, 0x2a, 0x37, 0xb9, 0x96, 0x2e, 0x4b, 0xe9, 0x93,
-	0x68, 0x77, 0x0f, 0x5a, 0xe8, 0x2f, 0x64, 0xf4, 0x33, 0xd9, 0x2f, 0x92, 0xba, 0xbb, 0x42, 0x58,
-	0x5b, 0xd6, 0xe8, 0x38, 0xdc, 0xb9, 0x17, 0x5c, 0x66, 0x29, 0xd7, 0xe3, 0xf0, 0x0e, 0x15, 0x88,
-	0xf0, 0x77, 0x02, 0x56, 0x98, 0x25, 0x5c, 0xf7, 0xf6, 0x5d, 0x70, 0x73, 0x54, 0x09, 0x7f, 0xe0,
-	0xf6, 0x99, 0xa2, 0x1b, 0x38, 0x9c, 0x30, 0x7c, 0x9f, 0xae, 0x72, 0x0a, 0x9a, 0xa1, 0xac, 0xb5,
-	0x6a, 0x32, 0x52, 0x12, 0x49, 0xe2, 0xeb, 0xa2, 0x9e, 0xfd, 0x9e, 0x00, 0xc7, 0xd2, 0x89, 0x29,
-	0xf0, 0x01, 0xcf, 0x76, 0x4d, 0x0b, 0x5f, 0x9f, 0x20, 0x0f, 0xa3, 0x1d, 0x10, 0xa9, 0x12, 0x1c,
-	0x2a, 0x0c, 0x5d, 0x51, 0xe8, 0xbe, 0xf4, 0xf6, 0xac, 0x12, 0x7b, 0xb9, 0x26, 0x98, 0xd1, 0x84,
-	0x5c, 0xa6, 0xe7, 0x66, 0x09, 0x3f, 0x17, 0x2c, 0xd9, 0xb4, 0x7e, 0x96, 0xb4, 0xf1, 0x06, 0x99,
-	0x45, 0x66, 0x5e, 0xc5, 0xc0, 0x46, 0x59, 0xcd, 0x9d, 0xe9, 0x3d, 0x59, 0xa5, 0x0d, 0xa7, 0xb6,
-	0x86, 0x6f, 0x84, 0xcd, 0x6b, 0x7a, 0xfb, 0x6f, 0x91, 0xe6, 0x3b, 0xd0, 0x4d, 0x69, 0x40, 0x2c,
-	0xc5, 0xd6, 0xae, 0x93, 0x6e, 0xd2, 0xb2, 0x98, 0x98, 0xb6, 0xbb, 0xe0, 0x49, 0xa7, 0x1e, 0xef,
-	0x96, 0xea, 0x99, 0xb5, 0x14, 0xc1, 0xc9, 0x7f, 0xe3, 0x83, 0xf0, 0x5a, 0x9e, 0x27, 0x8c, 0x2e,
-	0xb7, 0x15, 0x74, 0x48, 0x42, 0x99, 0x61, 0x26, 0xff, 0x5b, 0xc8, 0x85, 0x9d, 0x81, 0xc7, 0xa4,
-	0xbf, 0x4c, 0x8f, 0x16, 0xa9, 0xd7, 0x24, 0xec, 0x2c, 0x69, 0x9f, 0x37, 0xed, 0x80, 0xe0, 0x6d,
-	0xb0, 0x5a, 0x44, 0x11, 0x4b, 0x73, 0x27, 0xa5, 0x5a, 0x66, 0x7d, 0x84, 0xbb, 0x39, 0x8b, 0x38,
-	0x9c, 0xf2, 0x36, 0x3e, 0x05, 0xcf, 0x04, 0xc1, 0x10, 0x4b, 0x53, 0x77, 0xea, 0x41, 0xb5, 0x2b,
-	0xfb, 0xca, 0x28, 0x4e, 0xdf, 0x2f, 0x07, 0xa3, 0x58, 0xcd, 0xf7, 0x76, 0x19, 0x31, 0x69, 0xea,
-	0x5e, 0x78, 0xc4, 0x14, 0x5d, 0x9f, 0x16, 0xdd, 0x56, 0x8b, 0x72, 0x3c, 0x0b, 0xeb, 0xc4, 0x44,
-	0x8b, 0x38, 0x1c, 0xdf, 0x2f, 0x75, 0x32, 0xef, 0x10, 0x41, 0x89, 0x04, 0xf0, 0x1c, 0xbc, 0x36,
-	0xea, 0x79, 0x54, 0xf3, 0xf7, 0x49, 0x91, 0x13, 0xe9, 0xdc, 0xa6, 0xc9, 0x52, 0xd0, 0x98, 0xa7,
-	0xce, 0xa5, 0x69, 0x52, 0xa7, 0xe1, 0xdc, 0xb7, 0x0a, 0x1b, 0x9f, 0x48, 0x0e, 0x92, 0xa3, 0x5d,
-	0x0c, 0x66, 0x09, 0x0f, 0x87, 0x0f, 0x26, 0x85, 0x21, 0x65, 0x90, 0x4d, 0x44, 0xc3, 0x11, 0xb9,
-	0x5c, 0x30, 0x9e, 0x04, 0x02, 0x4d, 0x50, 0xae, 0x87, 0x1b, 0x05, 0xe3, 0x09, 0x60, 0x39, 0x35,
-	0x34, 0xef, 0x36, 0x70, 0x53, 0x0a, 0x1d, 0x46, 0x7b, 0x40, 0xa6, 0x4c, 0x5a, 0x2e, 0x6b, 0x2f,
-	0x12, 0xd3, 0xc2, 0x8e, 0x94, 0xbb, 0x35, 0x3d, 0x0c, 0x32, 0x28, 0x76, 0xa5, 0xe2, 0x11, 0x34,
-	0xda, 0x03, 0xbb, 0xc0, 0x28, 0x27, 0xd8, 0x93, 0x92, 0xdd, 0xbc, 0xcf, 0xd8, 0xa6, 0xdf, 0x8c,
-	0x06, 0xd7, 0x83, 0x12, 0x3d, 0x9a, 0x96, 0x2d, 0x71, 0xd1, 0xc2, 0x41, 0x2b, 0x35, 0x43, 0x9e,
-	0x19, 0x90, 0xeb, 0x38, 0x96, 0xae, 0xb8, 0x82, 0x63, 0xf2, 0x59, 0x75, 0x3c, 0x1a, 0x4b, 0xbf,
-	0x16, 0x12, 0xb2, 0x6a, 0x6b, 0xdf, 0x2d, 0x35, 0x33, 0xe9, 0x2b, 0x52, 0x61, 0xef, 0x81, 0x77,
-	0xa4, 0xc2, 0xe4, 0x98, 0x9a, 0x80, 0xdf, 0x88, 0x8a, 0x8a, 0xc7, 0xd5, 0x3d, 0x52, 0x2e, 0xb3,
-	0xd0, 0x31, 0x28, 0xc6, 0xd6, 0x69, 0xa9, 0x96, 0x29, 0x63, 0xd2, 0xa7, 0x1a, 0x2c, 0x67, 0x24,
-	0x7a, 0x14, 0xed, 0x85, 0xd0, 0xf4, 0x14, 0x9a, 0x94, 0xf0, 0x38, 0x3a, 0x00, 0xc1, 0x1d, 0xd3,
-	0x68, 0x0a, 0x0e, 0x76, 0xa1, 0x54, 0x4e, 0xd4, 0xb1, 0x08, 0xcf, 0xd8, 0x85, 0x52, 0x59, 0x11,
-	0xd3, 0xf0, 0x91, 0x75, 0xa1, 0x54, 0x96, 0xd5, 0x2b, 0xc1, 0x6f, 0x4c, 0x09, 0x10, 0xab, 0xb6,
-	0x86, 0x67, 0xe0, 0x01, 0xb4, 0x50, 0x2a, 0x4f, 0x93, 0x3a, 0x6b, 0x7b, 0x5c, 0xe5, 0x78, 0x16,
-	0xae, 0x5d, 0x0c, 0x12, 0x4b, 0xa1, 0xf3, 0xf0, 0xd2, 0xce, 0x53, 0xff, 0x52, 0x22, 0x3f, 0x06,
-	0x07, 0x27, 0x28, 0x85, 0xf8, 0x5d, 0xce, 0xc3, 0xd4, 0xbf, 0x24, 0x33, 0xe4, 0xf0, 0xe9, 0x4c,
-	0x11, 0x61, 0x8a, 0x81, 0x54, 0xc9, 0x34, 0xa4, 0x62, 0x54, 0xd4, 0x2b, 0x52, 0x2a, 0xb3, 0x1f,
-	0x05, 0xd6, 0xb1, 0x80, 0xab, 0x70, 0xd5, 0x04, 0x9b, 0xee, 0x8c, 0x35, 0xf8, 0x8d, 0x22, 0x4b,
-	0x11, 0xef, 0xaf, 0x36, 0x3c, 0x50, 0x05, 0x17, 0x43, 0x97, 0xf5, 0xc9, 0x3d, 0x95, 0x48, 0x8d,
-	0x5c, 0x76, 0xfd, 0x44, 0x61, 0x1f, 0xcb, 0x69, 0xb1, 0x91, 0x0e, 0x4e, 0x41, 0x8f, 0xe7, 0xf4,
-	0x3b, 0x6c, 0x5b, 0x07, 0x24, 0x8b, 0x7b, 0x25, 0xa7, 0x5f, 0x16, 0xdb, 0x41, 0x26, 0x2c, 0xef,
-	0x27, 0x72, 0x7a, 0x34, 0xec, 0x82, 0xc2, 0x8a, 0xe3, 0xff, 0x64, 0x4e, 0x8f, 0x86, 0x42, 0x07,
-	0x19, 0x63, 0x9f, 0xca, 0xe9, 0xfe, 0x49, 0x9f, 0xe2, 0x38, 0xb1, 0x6d, 0x93, 0xc9, 0xe0, 0x7e,
-	0x9e, 0xd3, 0x0d, 0xb9, 0x1b, 0xa0, 0x6a, 0x6b, 0x15, 0x4f, 0xcd, 0x86, 0x5f, 0x74, 0x89, 0x50,
-	0xa2, 0x89, 0xd2, 0xfd, 0xb2, 0x4b, 0x84, 0x92, 0x54, 0xd8, 0xaf, 0x94, 0xe0, 0xf1, 0xf4, 0x91,
-	0x5a, 0x62, 0x45, 0x46, 0xc2, 0x23, 0x72, 0x5d, 0x1c, 0x38, 0x2b, 0x1e, 0x7e, 0x2e, 0xa7, 0xa7,
-	0xd8, 0x4e, 0x00, 0x3f, 0x67, 0xb6, 0xc5, 0x4b, 0xb7, 0xe2, 0xe1, 0xe7, 0x73, 0x7a, 0xea, 0x8c,
-	0x82, 0x20, 0x6f, 0xc6, 0xf0, 0x0b, 0xbd, 0xe1, 0xb2, 0xe9, 0x98, 0x0d, 0x52, 0x59, 0x5e, 0x26,
-	0xac, 0xe2, 0xe1, 0x17, 0x15, 0x7c, 0x3b, 0x3a, 0xd4, 0x35, 0x62, 0x71, 0xc6, 0xa7, 0x2b, 0xda,
-	0xe6, 0xa5, 0x9c, 0xde, 0x11, 0x7b, 0xa0, 0x75, 0x20, 0xbc, 0xe2, 0x71, 0xea, 0x3a, 0x7e, 0xc5,
-	0xc3, 0x2f, 0xf7, 0x0e, 0x26, 0xba, 0x45, 0xd7, 0x58, 0xe0, 0x8b, 0xc8, 0xaf, 0xf5, 0x16, 0x9e,
-	0xb4, 0x6d, 0x77, 0x55, 0xb1, 0xaf, 0x28, 0xf6, 0x58, 0x7a, 0x10, 0x2b, 0x36, 0x2a, 0x72, 0x99,
-	0xb0, 0x06, 0xa9, 0x78, 0xf8, 0xd5, 0xde, 0xca, 0x51, 0x4d, 0xa6, 0x4d, 0x6e, 0x56, 0x3c, 0xfc,
-	0x5a, 0x6f, 0xe5, 0xa9, 0xa0, 0xe5, 0x55, 0x45, 0x03, 0x39, 0x75, 0xa1, 0xfc, 0x7a, 0x4e, 0xef,
-	0xe4, 0x1d, 0x5d, 0x9a, 0x32, 0xdc, 0x0d, 0x6f, 0xe4, 0xf4, 0xb4, 0x49, 0xf7, 0x38, 0x73, 0x9d,
-	0x44, 0xa3, 0xbd, 0x99, 0xd3, 0x83, 0x6b, 0x5b, 0x16, 0x53, 0xcc, 0x5b, 0x39, 0x7d, 0x48, 0xde,
-	0x9a, 0x65, 0xe4, 0x26, 0x78, 0xbb, 0xdb, 0x56, 0x97, 0x48, 0x18, 0xd2, 0x3b, 0x5d, 0xf6, 0x53,
-	0xd1, 0x64, 0x96, 0xe9, 0xb8, 0x52, 0xea, 0x1b, 0x79, 0xb8, 0x49, 0x25, 0x15, 0xbf, 0x69, 0x9f,
-	0xca, 0xeb, 0x0f, 0x03, 0x7b, 0x00, 0x30, 0xb5, 0xe3, 0xbf, 0xd9, 0x5b, 0x34, 0x06, 0xbf, 0x95,
-	0x87, 0xb7, 0x68, 0x2c, 0xaa, 0xaa, 0xf2, 0xed, 0x3c, 0xbc, 0x45, 0x25, 0xa9, 0xb0, 0xef, 0xe4,
-	0xf5, 0x3b, 0x76, 0x04, 0x4c, 0x47, 0x9c, 0x07, 0xae, 0xe6, 0xe1, 0x45, 0x4d, 0x54, 0x26, 0xac,
-	0xe0, 0x77, 0x95, 0x58, 0x66, 0xd6, 0x54, 0x1c, 0xee, 0xda, 0x6e, 0xa3, 0x9d, 0x08, 0xef, 0x37,
-	0x5d, 0x24, 0x15, 0xaa, 0xb8, 0xdf, 0xe6, 0xf5, 0x15, 0x7e, 0xb4, 0x8b, 0x64, 0x5c, 0x9d, 0xdf,
-	0xe5, 0xe1, 0x73, 0x9a, 0x82, 0x63, 0xf2, 0xf7, 0xeb, 0xc8, 0x86, 0x8b, 0xcd, 0x4c, 0xc7, 0x5f,
-	0x26, 0x0c, 0xff, 0x41, 0xc9, 0x66, 0xc6, 0x58, 0x12, 0x26, 0x96, 0xc6, 0xff, 0xa8, 0xb4, 0xc7,
-	0xd1, 0xfe, 0x6e, 0xf8, 0x05, 0xca, 0x9b, 0x16, 0x33, 0x57, 0x2b, 0x4e, 0x03, 0xff, 0x49, 0xc9,
-	0x9f, 0x44, 0xb7, 0x76, 0x97, 0x4f, 0x5a, 0xfc, 0x39, 0xaf, 0x3f, 0x3e, 0x74, 0xb5, 0xa8, 0x38,
-	0x7c, 0xce, 0x5a, 0x24, 0x0d, 0xea, 0x8b, 0xbb, 0xfc, 0x1b, 0x79, 0x78, 0xae, 0xa5, 0x7d, 0xa4,
-	0x6d, 0xfe, 0xa2, 0xbc, 0x9c, 0x42, 0x47, 0x7a, 0x7a, 0x99, 0xb4, 0xac, 0x49, 0xce, 0x19, 0x5d,
-	0x0a, 0x38, 0xf1, 0xf1, 0x5f, 0x95, 0xab, 0xbb, 0xd0, 0xb1, 0x75, 0x5c, 0xa5, 0x0d, 0xff, 0x96,
-	0xd7, 0xa7, 0x85, 0xd4, 0x26, 0x58, 0xa4, 0x9e, 0x67, 0x93, 0x44, 0xef, 0x3c, 0x3c, 0x00, 0xbf,
-	0x6f, 0x23, 0x50, 0x51, 0x1f, 0x1d, 0x80, 0x3b, 0x3b, 0xa2, 0xe4, 0x6e, 0x7e, 0x64, 0x00, 0xde,
-	0x25, 0x31, 0x14, 0x36, 0xf6, 0xa3, 0x0a, 0x7b, 0x37, 0x1a, 0x4b, 0xdd, 0x9f, 0x5d, 0x87, 0x30,
-	0x37, 0x5c, 0x79, 0xb3, 0x2e, 0x66, 0xfc, 0x9c, 0x43, 0xb9, 0x1a, 0x00, 0x7f, 0x1f, 0xd0, 0x17,
-	0xbb, 0x03, 0xeb, 0x1a, 0x89, 0x6d, 0xf6, 0x0f, 0x65, 0x90, 0xa9, 0x5c, 0x87, 0x41, 0x95, 0xf0,
-	0x39, 0xc7, 0x0b, 0xb4, 0xa7, 0x7f, 0x2a, 0xc3, 0xf5, 0xc2, 0x53, 0x86, 0xc2, 0xdb, 0xbf, 0x94,
-	0xd1, 0x19, 0x74, 0x6a, 0x9d, 0xf0, 0xbc, 0x80, 0xfb, 0xe7, 0x08, 0x6b, 0x05, 0xdc, 0x14, 0x7f,
-	0x50, 0x6e, 0xff, 0xad, 0x14, 0x4e, 0xa3, 0xdb, 0xfe, 0x3f, 0x05, 0xe1, 0xff, 0x4d, 0x65, 0x7d,
-	0x37, 0x3a, 0xbe, 0xbe, 0xf5, 0x79, 0xea, 0x50, 0xe5, 0xf7, 0x2d, 0x65, 0x79, 0x07, 0x3a, 0xdc,
-	0x9f, 0xa5, 0xf0, 0xf7, 0xb6, 0xb2, 0xba, 0x07, 0x9d, 0xec, 0x69, 0x35, 0x69, 0xdb, 0x51, 0xc0,
-	0x55, 0xa2, 0x2b, 0xfc, 0x4e, 0xbf, 0x4b, 0x93, 0x34, 0x16, 0x5e, 0xff, 0xd3, 0x6f, 0x96, 0xe2,
-	0x98, 0x10, 0xf0, 0xc4, 0xa2, 0xfe, 0xb7, 0xdf, 0x2c, 0xb5, 0xa5, 0xf0, 0xf7, 0x7e, 0xa3, 0x4f,
-	0x7f, 0x93, 0xb6, 0x5d, 0x09, 0x78, 0x22, 0xc5, 0x0f, 0x18, 0x7d, 0xfa, 0xd3, 0x96, 0xc2, 0xdf,
-	0x07, 0xfb, 0xf5, 0x17, 0x7e, 0xf4, 0x49, 0x36, 0xed, 0x87, 0xfa, 0xf5, 0xa7, 0x2d, 0x85, 0xbf,
-	0x0f, 0xf7, 0x6b, 0x35, 0x43, 0x1d, 0xd3, 0x56, 0xbe, 0x3e, 0x62, 0xc0, 0x03, 0x13, 0xb6, 0x12,
-	0x7e, 0x1e, 0x52, 0x16, 0x77, 0xa2, 0xa3, 0x9d, 0x16, 0x67, 0x49, 0x7b, 0xae, 0x65, 0x36, 0x48,
-	0x69, 0xcd, 0x73, 0x19, 0x4f, 0x6e, 0xfa, 0x47, 0x94, 0x5d, 0x66, 0xd0, 0x76, 0xb3, 0x13, 0xbe,
-	0x1e, 0xed, 0x99, 0x93, 0xb2, 0xa9, 0xb6, 0x9d, 0x7a, 0x95, 0x13, 0x7d, 0x5a, 0xff, 0x58, 0xcf,
-	0x9c, 0xb2, 0x56, 0xc2, 0xcf, 0xc7, 0x0d, 0x78, 0xa0, 0x77, 0x5a, 0xa4, 0x8a, 0xf7, 0x98, 0x32,
-	0xbb, 0x0d, 0x1d, 0xec, 0xc3, 0x4c, 0x78, 0x7a, 0xdc, 0x80, 0x47, 0x79, 0x64, 0x92, 0x18, 0xe5,
-	0x9f, 0x36, 0xe0, 0x51, 0x1e, 0x81, 0x8a, 0xfa, 0x8c, 0x01, 0x9f, 0x7a, 0xb4, 0xdc, 0x05, 0x93,
-	0xd7, 0x9b, 0xe2, 0xbd, 0xfe, 0x59, 0x03, 0x9e, 0xe7, 0x11, 0xa9, 0xb1, 0xcf, 0x19, 0xf0, 0xc5,
-	0x24, 0xfc, 0x50, 0x14, 0xb1, 0xd3, 0xd4, 0x6c, 0xa8, 0x0a, 0x7c, 0xde, 0x80, 0xef, 0x50, 0x19,
-	0x5c, 0x64, 0xfe, 0x05, 0xa5, 0x9c, 0x39, 0x2d, 0xeb, 0x50, 0x6b, 0x6b, 0x67, 0x89, 0xfe, 0xa9,
-	0xe3, 0x8b, 0x06, 0x7c, 0x60, 0x49, 0xd3, 0x42, 0xf7, 0x4b, 0x3d, 0x7b, 0x64, 0x9e, 0xae, 0x90,
-	0x45, 0xb2, 0xcc, 0x88, 0xdf, 0xac, 0x72, 0x93, 0xe9, 0x6e, 0x7c, 0xd2, 0x80, 0x8f, 0x16, 0xb0,
-	0x95, 0xf0, 0xf3, 0x65, 0xa3, 0xd7, 0xab, 0x24, 0x65, 0x11, 0xb7, 0xe2, 0x57, 0x94, 0x1b, 0xf0,
-	0x4d, 0x97, 0x31, 0x12, 0x5e, 0xbe, 0xda, 0x6f, 0x36, 0xa9, 0x46, 0xfc, 0x5a, 0xbf, 0xd9, 0xe8,
-	0x3e, 0xfc, 0xba, 0x01, 0x7f, 0x0a, 0x28, 0x65, 0x6e, 0xdc, 0xd7, 0x0c, 0xf8, 0x7e, 0x50, 0x4a,
-	0xde, 0xb7, 0x5f, 0x31, 0xf4, 0x67, 0x96, 0x2d, 0x19, 0x48, 0x9e, 0x26, 0x5e, 0xed, 0xd2, 0x27,
-	0x25, 0xd7, 0x17, 0x07, 0xe9, 0xe4, 0xbb, 0xf3, 0xd7, 0x06, 0x7c, 0xff, 0x49, 0xa0, 0x22, 0x81,
-	0xd7, 0x0c, 0xf8, 0xfe, 0x53, 0x4a, 0x7c, 0x58, 0x78, 0xbd, 0xcb, 0xee, 0x98, 0xa2, 0x8e, 0xe9,
-	0xd4, 0x93, 0x07, 0xa7, 0x1f, 0x0c, 0xc2, 0xbb, 0x43, 0x92, 0x0a, 0xfb, 0xe1, 0x20, 0x7c, 0x73,
-	0x89, 0x05, 0xe3, 0xa2, 0xfc, 0x68, 0x10, 0xbe, 0xb9, 0x48, 0x36, 0x06, 0x7f, 0x3c, 0x08, 0xdf,
-	0xae, 0x24, 0x28, 0x2b, 0xf8, 0x74, 0x6f, 0xb9, 0xf8, 0x76, 0xf5, 0x93, 0x41, 0xf8, 0xaa, 0xa1,
-	0x40, 0x79, 0x18, 0x2f, 0xfb, 0x0d, 0xfc, 0xcc, 0x20, 0x7c, 0xd5, 0x90, 0x68, 0x85, 0x59, 0x11,
-	0xf7, 0x6c, 0x6f, 0xdf, 0xd1, 0x8f, 0xb4, 0x02, 0xfc, 0x69, 0x6f, 0x41, 0xbd, 0x30, 0x3f, 0x93,
-	0x31, 0x4e, 0x9c, 0x46, 0xd7, 0xaf, 0x52, 0x46, 0x2e, 0x52, 0x67, 0x78, 0xef, 0x78, 0xf4, 0x4b,
-	0xff, 0xb8, 0xfa, 0xa5, 0x7f, 0xbc, 0xe4, 0x04, 0xad, 0xf0, 0xe7, 0x12, 0xf9, 0x95, 0x60, 0xe4,
-	0xb9, 0x87, 0x06, 0x46, 0x73, 0x63, 0x43, 0x8b, 0xd7, 0x09, 0x9b, 0x39, 0x67, 0xe2, 0x5e, 0x34,
-	0x14, 0x5a, 0xbb, 0x01, 0xef, 0xc7, 0xfc, 0x79, 0x69, 0x1e, 0xba, 0xac, 0x04, 0x7c, 0x62, 0x16,
-	0x6d, 0x0a, 0xed, 0x2d, 0x31, 0xad, 0xfa, 0x8c, 0xe1, 0x05, 0x29, 0xb2, 0x41, 0x58, 0x86, 0x63,
-	0x6e, 0xce, 0x99, 0x98, 0x43, 0x9b, 0x13, 0x42, 0x7d, 0x86, 0xf3, 0xa2, 0x54, 0xda, 0xa8, 0x95,
-	0x44, 0x4c, 0x67, 0xd0, 0x0d, 0xa1, 0x14, 0xa7, 0x4e, 0xbb, 0x1f, 0x95, 0x97, 0xa4, 0x4a, 0x58,
-	0x89, 0x1a, 0x75, 0xda, 0x13, 0xf3, 0xe8, 0xc6, 0x50, 0x61, 0xc9, 0x75, 0xb9, 0xed, 0x9a, 0x16,
-	0x61, 0xfd, 0xe8, 0xbc, 0x2c, 0x75, 0xc2, 0x44, 0xa6, 0xb4, 0xe9, 0x44, 0x11, 0x85, 0x99, 0x5e,
-	0x74, 0xdc, 0x8b, 0xcb, 0x7e, 0xab, 0x1f, 0xa5, 0x6b, 0x52, 0x29, 0xcc, 0x63, 0xc1, 0x9d, 0xf1,
-	0x5b, 0x53, 0x77, 0xa0, 0xfd, 0x75, 0xb7, 0x35, 0xee, 0x9b, 0xdc, 0xf5, 0x9b, 0xd4, 0x36, 0x97,
-	0x7c, 0xf5, 0xff, 0x79, 0xd8, 0x74, 0x49, 0x4b, 0x4d, 0x6d, 0xaa, 0x85, 0x7f, 0x94, 0x9d, 0xf3,
-	0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x69, 0x67, 0x5d, 0x1f, 0x22, 0x00, 0x00,
-}
--- a/accounts/usbwallet/trezor/messages.proto
+++ b/accounts/usbwallet/trezor/messages.proto
@ -1,264 +0,0 @@
-// This file originates from the SatoshiLabs Trezor `common` repository at:
-//   https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
-// dated 28.05.2019, commit 893fd219d4a01bcffa0cd9cfa631856371ec5aa9.
-
-syntax = "proto2";
-package hw.trezor.messages;
-
-/**
- * Messages for TREZOR communication
- */
-
-// Sugar for easier handling in Java
-option java_package = "com.satoshilabs.trezor.lib.protobuf";
-option java_outer_classname = "TrezorMessage";
-
-import "google/protobuf/descriptor.proto";
-
-/**
- * Options for specifying message direction and type of wire (normal/debug)
- */
-extend google.protobuf.EnumValueOptions {
-    optional bool wire_in = 50002;              // message can be transmitted via wire from PC to TREZOR
-    optional bool wire_out = 50003;             // message can be transmitted via wire from TREZOR to PC
-    optional bool wire_debug_in = 50004;        // message can be transmitted via debug wire from PC to TREZOR
-    optional bool wire_debug_out = 50005;       // message can be transmitted via debug wire from TREZOR to PC
-    optional bool wire_tiny = 50006;            // message is handled by TREZOR when the USB stack is in tiny mode
-    optional bool wire_bootloader = 50007;      // message is only handled by TREZOR Bootloader
-    optional bool wire_no_fsm = 50008;          // message is not handled by TREZOR unless the USB stack is in tiny mode
-}
-
-/**
- * Mapping between TREZOR wire identifier (uint) and a protobuf message
- */
-enum MessageType {
-
-    // Management
-    MessageType_Initialize = 0 [(wire_in) = true, (wire_tiny) = true];
-    MessageType_Ping = 1 [(wire_in) = true];
-    MessageType_Success = 2 [(wire_out) = true];
-    MessageType_Failure = 3 [(wire_out) = true];
-    MessageType_ChangePin = 4 [(wire_in) = true];
-    MessageType_WipeDevice = 5 [(wire_in) = true];
-    MessageType_GetEntropy = 9 [(wire_in) = true];
-    MessageType_Entropy = 10 [(wire_out) = true];
-    MessageType_LoadDevice = 13 [(wire_in) = true];
-    MessageType_ResetDevice = 14 [(wire_in) = true];
-    MessageType_Features = 17 [(wire_out) = true];
-    MessageType_PinMatrixRequest = 18 [(wire_out) = true];
-    MessageType_PinMatrixAck = 19 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
-    MessageType_Cancel = 20 [(wire_in) = true, (wire_tiny) = true];
-    MessageType_ClearSession = 24 [(wire_in) = true];
-    MessageType_ApplySettings = 25 [(wire_in) = true];
-    MessageType_ButtonRequest = 26 [(wire_out) = true];
-    MessageType_ButtonAck = 27 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
-    MessageType_ApplyFlags = 28 [(wire_in) = true];
-    MessageType_BackupDevice = 34 [(wire_in) = true];
-    MessageType_EntropyRequest = 35 [(wire_out) = true];
-    MessageType_EntropyAck = 36 [(wire_in) = true];
-    MessageType_PassphraseRequest = 41 [(wire_out) = true];
-    MessageType_PassphraseAck = 42 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
-    MessageType_PassphraseStateRequest = 77 [(wire_out) = true];
-    MessageType_PassphraseStateAck = 78 [(wire_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
-    MessageType_RecoveryDevice = 45 [(wire_in) = true];
-    MessageType_WordRequest = 46 [(wire_out) = true];
-    MessageType_WordAck = 47 [(wire_in) = true];
-    MessageType_GetFeatures = 55 [(wire_in) = true];
-    MessageType_SetU2FCounter = 63 [(wire_in) = true];
-
-    // Bootloader
-    MessageType_FirmwareErase = 6 [(wire_in) = true, (wire_bootloader) = true];
-    MessageType_FirmwareUpload = 7 [(wire_in) = true, (wire_bootloader) = true];
-    MessageType_FirmwareRequest = 8 [(wire_out) = true, (wire_bootloader) = true];
-    MessageType_SelfTest = 32 [(wire_in) = true, (wire_bootloader) = true];
-
-    // Bitcoin
-    MessageType_GetPublicKey = 11 [(wire_in) = true];
-    MessageType_PublicKey = 12 [(wire_out) = true];
-    MessageType_SignTx = 15 [(wire_in) = true];
-    MessageType_TxRequest = 21 [(wire_out) = true];
-    MessageType_TxAck = 22 [(wire_in) = true];
-    MessageType_GetAddress = 29 [(wire_in) = true];
-    MessageType_Address = 30 [(wire_out) = true];
-    MessageType_SignMessage = 38 [(wire_in) = true];
-    MessageType_VerifyMessage = 39 [(wire_in) = true];
-    MessageType_MessageSignature = 40 [(wire_out) = true];
-
-    // Crypto
-    MessageType_CipherKeyValue = 23 [(wire_in) = true];
-    MessageType_CipheredKeyValue = 48 [(wire_out) = true];
-    MessageType_SignIdentity = 53 [(wire_in) = true];
-    MessageType_SignedIdentity = 54 [(wire_out) = true];
-    MessageType_GetECDHSessionKey = 61 [(wire_in) = true];
-    MessageType_ECDHSessionKey = 62 [(wire_out) = true];
-    MessageType_CosiCommit = 71 [(wire_in) = true];
-    MessageType_CosiCommitment = 72 [(wire_out) = true];
-    MessageType_CosiSign = 73 [(wire_in) = true];
-    MessageType_CosiSignature = 74 [(wire_out) = true];
-
-    // Debug
-    MessageType_DebugLinkDecision = 100 [(wire_debug_in) = true, (wire_tiny) = true, (wire_no_fsm) = true];
-    MessageType_DebugLinkGetState = 101 [(wire_debug_in) = true, (wire_tiny) = true];
-    MessageType_DebugLinkState = 102 [(wire_debug_out) = true];
-    MessageType_DebugLinkStop = 103 [(wire_debug_in) = true];
-    MessageType_DebugLinkLog = 104 [(wire_debug_out) = true];
-    MessageType_DebugLinkMemoryRead = 110 [(wire_debug_in) = true];
-    MessageType_DebugLinkMemory = 111 [(wire_debug_out) = true];
-    MessageType_DebugLinkMemoryWrite = 112 [(wire_debug_in) = true];
-    MessageType_DebugLinkFlashErase = 113 [(wire_debug_in) = true];
-
-    // Ethereum
-    MessageType_EthereumGetPublicKey = 450 [(wire_in) = true];
-    MessageType_EthereumPublicKey = 451 [(wire_out) = true];
-    MessageType_EthereumGetAddress = 56 [(wire_in) = true];
-    MessageType_EthereumAddress = 57 [(wire_out) = true];
-    MessageType_EthereumSignTx = 58 [(wire_in) = true];
-    MessageType_EthereumTxRequest = 59 [(wire_out) = true];
-    MessageType_EthereumTxAck = 60 [(wire_in) = true];
-    MessageType_EthereumSignMessage = 64 [(wire_in) = true];
-    MessageType_EthereumVerifyMessage = 65 [(wire_in) = true];
-    MessageType_EthereumMessageSignature = 66 [(wire_out) = true];
-
-    // NEM
-    MessageType_NEMGetAddress = 67 [(wire_in) = true];
-    MessageType_NEMAddress = 68 [(wire_out) = true];
-    MessageType_NEMSignTx = 69 [(wire_in) = true];
-    MessageType_NEMSignedTx = 70 [(wire_out) = true];
-    MessageType_NEMDecryptMessage = 75 [(wire_in) = true];
-    MessageType_NEMDecryptedMessage = 76 [(wire_out) = true];
-
-    // Lisk
-    MessageType_LiskGetAddress = 114 [(wire_in) = true];
-    MessageType_LiskAddress = 115 [(wire_out) = true];
-    MessageType_LiskSignTx = 116 [(wire_in) = true];
-    MessageType_LiskSignedTx = 117 [(wire_out) = true];
-    MessageType_LiskSignMessage = 118 [(wire_in) = true];
-    MessageType_LiskMessageSignature = 119 [(wire_out) = true];
-    MessageType_LiskVerifyMessage = 120 [(wire_in) = true];
-    MessageType_LiskGetPublicKey = 121 [(wire_in) = true];
-    MessageType_LiskPublicKey = 122 [(wire_out) = true];
-
-    // Tezos
-    MessageType_TezosGetAddress = 150 [(wire_in) = true];
-    MessageType_TezosAddress = 151 [(wire_out) = true];
-    MessageType_TezosSignTx = 152 [(wire_in) = true];
-    MessageType_TezosSignedTx = 153 [(wire_out) = true];
-    MessageType_TezosGetPublicKey = 154 [(wire_in) = true];
-    MessageType_TezosPublicKey = 155 [(wire_out) = true];
-
-    // Stellar
-    MessageType_StellarSignTx = 202 [(wire_in) = true];
-    MessageType_StellarTxOpRequest = 203 [(wire_out) = true];
-    MessageType_StellarGetAddress = 207 [(wire_in) = true];
-    MessageType_StellarAddress = 208 [(wire_out) = true];
-    MessageType_StellarCreateAccountOp = 210 [(wire_in) = true];
-    MessageType_StellarPaymentOp = 211 [(wire_in) = true];
-    MessageType_StellarPathPaymentOp = 212 [(wire_in) = true];
-    MessageType_StellarManageOfferOp = 213 [(wire_in) = true];
-    MessageType_StellarCreatePassiveOfferOp = 214 [(wire_in) = true];
-    MessageType_StellarSetOptionsOp = 215 [(wire_in) = true];
-    MessageType_StellarChangeTrustOp = 216 [(wire_in) = true];
-    MessageType_StellarAllowTrustOp = 217 [(wire_in) = true];
-    MessageType_StellarAccountMergeOp = 218 [(wire_in) = true];
-    // omitted: StellarInflationOp is not a supported operation, would be 219
-    MessageType_StellarManageDataOp = 220 [(wire_in) = true];
-    MessageType_StellarBumpSequenceOp = 221 [(wire_in) = true];
-    MessageType_StellarSignedTx = 230 [(wire_out) = true];
-
-    // TRON
-    MessageType_TronGetAddress = 250 [(wire_in) = true];
-    MessageType_TronAddress = 251 [(wire_out) = true];
-    MessageType_TronSignTx = 252 [(wire_in) = true];
-    MessageType_TronSignedTx = 253 [(wire_out) = true];
-
-    // Cardano
-    // dropped Sign/VerifyMessage ids 300-302
-    MessageType_CardanoSignTx = 303 [(wire_in) = true];
-    MessageType_CardanoTxRequest = 304 [(wire_out) = true];
-    MessageType_CardanoGetPublicKey = 305 [(wire_in) = true];
-    MessageType_CardanoPublicKey = 306 [(wire_out) = true];
-    MessageType_CardanoGetAddress = 307 [(wire_in) = true];
-    MessageType_CardanoAddress = 308 [(wire_out) = true];
-    MessageType_CardanoTxAck = 309 [(wire_in) = true];
-    MessageType_CardanoSignedTx = 310 [(wire_out) = true];
-
-    // Ontology
-    MessageType_OntologyGetAddress = 350 [(wire_in) = true];
-    MessageType_OntologyAddress = 351 [(wire_out) = true];
-    MessageType_OntologyGetPublicKey = 352 [(wire_in) = true];
-    MessageType_OntologyPublicKey = 353 [(wire_out) = true];
-    MessageType_OntologySignTransfer = 354 [(wire_in) = true];
-    MessageType_OntologySignedTransfer = 355 [(wire_out) = true];
-    MessageType_OntologySignWithdrawOng = 356 [(wire_in) = true];
-    MessageType_OntologySignedWithdrawOng = 357 [(wire_out) = true];
-    MessageType_OntologySignOntIdRegister = 358 [(wire_in) = true];
-    MessageType_OntologySignedOntIdRegister = 359 [(wire_out) = true];
-    MessageType_OntologySignOntIdAddAttributes = 360 [(wire_in) = true];
-    MessageType_OntologySignedOntIdAddAttributes = 361 [(wire_out) = true];
-
-    // Ripple
-    MessageType_RippleGetAddress = 400 [(wire_in) = true];
-    MessageType_RippleAddress = 401 [(wire_out) = true];
-    MessageType_RippleSignTx = 402 [(wire_in) = true];
-    MessageType_RippleSignedTx = 403 [(wire_in) = true];
-
-    // Monero
-    MessageType_MoneroTransactionInitRequest = 501 [(wire_out) = true];
-    MessageType_MoneroTransactionInitAck = 502 [(wire_out) = true];
-    MessageType_MoneroTransactionSetInputRequest = 503 [(wire_out) = true];
-    MessageType_MoneroTransactionSetInputAck = 504 [(wire_out) = true];
-    MessageType_MoneroTransactionInputsPermutationRequest = 505 [(wire_out) = true];
-    MessageType_MoneroTransactionInputsPermutationAck = 506 [(wire_out) = true];
-    MessageType_MoneroTransactionInputViniRequest = 507 [(wire_out) = true];
-    MessageType_MoneroTransactionInputViniAck = 508 [(wire_out) = true];
-    MessageType_MoneroTransactionAllInputsSetRequest = 509 [(wire_out) = true];
-    MessageType_MoneroTransactionAllInputsSetAck = 510 [(wire_out) = true];
-    MessageType_MoneroTransactionSetOutputRequest = 511 [(wire_out) = true];
-    MessageType_MoneroTransactionSetOutputAck = 512 [(wire_out) = true];
-    MessageType_MoneroTransactionAllOutSetRequest = 513 [(wire_out) = true];
-    MessageType_MoneroTransactionAllOutSetAck = 514 [(wire_out) = true];
-    MessageType_MoneroTransactionSignInputRequest = 515 [(wire_out) = true];
-    MessageType_MoneroTransactionSignInputAck = 516 [(wire_out) = true];
-    MessageType_MoneroTransactionFinalRequest = 517 [(wire_out) = true];
-    MessageType_MoneroTransactionFinalAck = 518 [(wire_out) = true];
-    MessageType_MoneroKeyImageExportInitRequest = 530 [(wire_out) = true];
-    MessageType_MoneroKeyImageExportInitAck = 531 [(wire_out) = true];
-    MessageType_MoneroKeyImageSyncStepRequest = 532 [(wire_out) = true];
-    MessageType_MoneroKeyImageSyncStepAck = 533 [(wire_out) = true];
-    MessageType_MoneroKeyImageSyncFinalRequest = 534 [(wire_out) = true];
-    MessageType_MoneroKeyImageSyncFinalAck = 535 [(wire_out) = true];
-    MessageType_MoneroGetAddress = 540 [(wire_in) = true];
-    MessageType_MoneroAddress = 541 [(wire_out) = true];
-    MessageType_MoneroGetWatchKey = 542 [(wire_in) = true];
-    MessageType_MoneroWatchKey = 543 [(wire_out) = true];
-    MessageType_DebugMoneroDiagRequest = 546 [(wire_in) = true];
-    MessageType_DebugMoneroDiagAck = 547 [(wire_out) = true];
-    MessageType_MoneroGetTxKeyRequest = 550 [(wire_in) = true];
-    MessageType_MoneroGetTxKeyAck = 551 [(wire_out) = true];
-    MessageType_MoneroLiveRefreshStartRequest = 552 [(wire_in) = true];
-    MessageType_MoneroLiveRefreshStartAck = 553 [(wire_out) = true];
-    MessageType_MoneroLiveRefreshStepRequest = 554 [(wire_in) = true];
-    MessageType_MoneroLiveRefreshStepAck = 555 [(wire_out) = true];
-    MessageType_MoneroLiveRefreshFinalRequest = 556 [(wire_in) = true];
-    MessageType_MoneroLiveRefreshFinalAck = 557 [(wire_out) = true];
-
-    // EOS
-    MessageType_EosGetPublicKey = 600 [(wire_in) = true];
-    MessageType_EosPublicKey = 601 [(wire_out) = true];
-    MessageType_EosSignTx = 602 [(wire_in) = true];
-    MessageType_EosTxActionRequest = 603 [(wire_out) = true];
-    MessageType_EosTxActionAck = 604 [(wire_in) = true];
-    MessageType_EosSignedTx = 605 [(wire_out) = true];
-
-    // Binance
-    MessageType_BinanceGetAddress = 700 [(wire_in) = true];
-    MessageType_BinanceAddress = 701 [(wire_out) = true];
-    MessageType_BinanceGetPublicKey = 702 [(wire_in) = true];
-    MessageType_BinancePublicKey = 703 [(wire_out) = true];
-    MessageType_BinanceSignTx = 704 [(wire_in) = true];
-    MessageType_BinanceTxRequest = 705 [(wire_out) = true];
-    MessageType_BinanceTransferMsg = 706 [(wire_in) = true];
-    MessageType_BinanceOrderMsg = 707 [(wire_in) = true];
-    MessageType_BinanceCancelMsg = 708 [(wire_in) = true];
-    MessageType_BinanceSignedTx = 709 [(wire_out) = true];
-}
--- a/accounts/usbwallet/trezor/trezor.go
+++ b/accounts/usbwallet/trezor/trezor.go
@ -1,70 +0,0 @@
-// Copyright 2017 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-// This file contains the implementation for interacting with the Trezor hardware
-// wallets. The wire protocol spec can be found on the SatoshiLabs website:
-// https://wiki.trezor.io/Developers_guide-Message_Workflows
-
-// !!! STAHP !!!
-//
-// Before you touch the protocol files, you need to be aware of a breaking change
-// that occurred between firmware versions 1.7.3->1.8.0 (Model One) and 2.0.10->
-// 2.1.0 (Model T). The Ethereum address representation was changed from the 20
-// byte binary blob to a 42 byte hex string. The upstream protocol buffer files
-// only support the new format, so blindly pulling in a new spec will break old
-// devices!
-//
-// The Trezor devs had the foresight to add the string version as a new message
-// code instead of replacing the binary one. This means that the proto file can
-// actually define both the old and the new versions as optional. Please ensure
-// that you add back the old addresses everywhere (to avoid name clash. use the
-// addressBin and addressHex names).
-//
-// If in doubt, reach out to @karalabe.
-
-// To regenerate the protocol files in this package:
-//   - Download the latest protoc https://github.com/protocolbuffers/protobuf/releases
-//   - Build with the usual `./configure && make` and ensure it's on your $PATH
-//   - Delete all the .proto and .pb.go files, pull in fresh ones from Trezor
-//   - Grab the latest Go plugin `go get -u github.com/golang/protobuf/protoc-gen-go`
-//   - Vendor in the latest Go plugin `govendor fetch github.com/golang/protobuf/...`
-
-//go:generate protoc -I/usr/local/include:. --go_out=import_path=trezor:. messages.proto messages-common.proto messages-management.proto messages-ethereum.proto
-
-// Package trezor contains the wire protocol.
-package trezor
-
-import (
-	"reflect"
-
-	"github.com/golang/protobuf/proto"
-)
-
-// Type returns the protocol buffer type number of a specific message. If the
-// message is nil, this method panics!
-func Type(msg proto.Message) uint16 {
-	return uint16(MessageType_value["MessageType_"+reflect.TypeOf(msg).Elem().Name()])
-}
-
-// Name returns the friendly message type name of a specific protocol buffer
-// type number.
-func Name(kind uint16) string {
-	name := MessageType_name[int32(kind)]
-	if len(name) < 12 {
-		return name
-	}
-	return name[12:]
-}
--- a/api/act.go
+++ b/api/act.go
@ -0,0 +1,538 @@
+package api
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/crypto/ecies"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/sctx"
+	"github.com/ethersphere/swarm/storage"
+	"golang.org/x/crypto/scrypt"
+	"golang.org/x/crypto/sha3"
+	cli "gopkg.in/urfave/cli.v1"
+)
+
+var (
+	ErrDecrypt                = errors.New("cant decrypt - forbidden")
+	ErrUnknownAccessType      = errors.New("unknown access type (or not implemented)")
+	ErrDecryptDomainForbidden = errors.New("decryption request domain forbidden - can only decrypt on localhost")
+	AllowedDecryptDomains     = []string{
+		"localhost",
+		"127.0.0.1",
+	}
+)
+
+const EmptyCredentials = ""
+
+type AccessEntry struct {
+	Type      AccessType
+	Publisher string
+	Salt      []byte
+	Act       string
+	KdfParams *KdfParams
+}
+
+type DecryptFunc func(*ManifestEntry) error
+
+func (a *AccessEntry) MarshalJSON() (out []byte, err error) {
+
+	return json.Marshal(struct {
+		Type      AccessType `json:"type,omitempty"`
+		Publisher string     `json:"publisher,omitempty"`
+		Salt      string     `json:"salt,omitempty"`
+		Act       string     `json:"act,omitempty"`
+		KdfParams *KdfParams `json:"kdf_params,omitempty"`
+	}{
+		Type:      a.Type,
+		Publisher: a.Publisher,
+		Salt:      hex.EncodeToString(a.Salt),
+		Act:       a.Act,
+		KdfParams: a.KdfParams,
+	})
+
+}
+
+func (a *AccessEntry) UnmarshalJSON(value []byte) error {
+	v := struct {
+		Type      AccessType `json:"type,omitempty"`
+		Publisher string     `json:"publisher,omitempty"`
+		Salt      string     `json:"salt,omitempty"`
+		Act       string     `json:"act,omitempty"`
+		KdfParams *KdfParams `json:"kdf_params,omitempty"`
+	}{}
+
+	err := json.Unmarshal(value, &v)
+	if err != nil {
+		return err
+	}
+	a.Act = v.Act
+	a.KdfParams = v.KdfParams
+	a.Publisher = v.Publisher
+	a.Salt, err = hex.DecodeString(v.Salt)
+	if err != nil {
+		return err
+	}
+	if len(a.Salt) != 32 {
+		return errors.New("salt should be 32 bytes long")
+	}
+	a.Type = v.Type
+	return nil
+}
+
+type KdfParams struct {
+	N int `json:"n"`
+	P int `json:"p"`
+	R int `json:"r"`
+}
+
+type AccessType string
+
+const AccessTypePass = AccessType("pass")
+const AccessTypePK = AccessType("pk")
+const AccessTypeACT = AccessType("act")
+
+// NewAccessEntryPassword creates a manifest AccessEntry in order to create an ACT protected by a password
+func NewAccessEntryPassword(salt []byte, kdfParams *KdfParams) (*AccessEntry, error) {
+	if len(salt) != 32 {
+		return nil, fmt.Errorf("salt should be 32 bytes long")
+	}
+	return &AccessEntry{
+		Type:      AccessTypePass,
+		Salt:      salt,
+		KdfParams: kdfParams,
+	}, nil
+}
+
+// NewAccessEntryPK creates a manifest AccessEntry in order to create an ACT protected by a pair of Elliptic Curve keys
+func NewAccessEntryPK(publisher string, salt []byte) (*AccessEntry, error) {
+	if len(publisher) != 66 {
+		return nil, fmt.Errorf("publisher should be 66 characters long, got %d", len(publisher))
+	}
+	if len(salt) != 32 {
+		return nil, fmt.Errorf("salt should be 32 bytes long")
+	}
+	return &AccessEntry{
+		Type:      AccessTypePK,
+		Publisher: publisher,
+		Salt:      salt,
+	}, nil
+}
+
+// NewAccessEntryACT creates a manifest AccessEntry in order to create an ACT protected by a combination of EC keys and passwords
+func NewAccessEntryACT(publisher string, salt []byte, act string) (*AccessEntry, error) {
+	if len(salt) != 32 {
+		return nil, fmt.Errorf("salt should be 32 bytes long")
+	}
+	if len(publisher) != 66 {
+		return nil, fmt.Errorf("publisher should be 66 characters long")
+	}
+
+	return &AccessEntry{
+		Type:      AccessTypeACT,
+		Publisher: publisher,
+		Salt:      salt,
+		Act:       act,
+		KdfParams: DefaultKdfParams,
+	}, nil
+}
+
+// NOOPDecrypt is a generic decrypt function that is passed into the API in places where real ACT decryption capabilities are
+// either unwanted, or alternatively, cannot be implemented in the immediate scope
+func NOOPDecrypt(*ManifestEntry) error {
+	return nil
+}
+
+var DefaultKdfParams = NewKdfParams(262144, 1, 8)
+
+// NewKdfParams returns a KdfParams struct with the given scrypt params
+func NewKdfParams(n, p, r int) *KdfParams {
+
+	return &KdfParams{
+		N: n,
+		P: p,
+		R: r,
+	}
+}
+
+// NewSessionKeyPassword creates a session key based on a shared secret (password) and the given salt
+// and kdf parameters in the access entry
+func NewSessionKeyPassword(password string, accessEntry *AccessEntry) ([]byte, error) {
+	if accessEntry.Type != AccessTypePass && accessEntry.Type != AccessTypeACT {
+		return nil, errors.New("incorrect access entry type")
+
+	}
+	return sessionKeyPassword(password, accessEntry.Salt, accessEntry.KdfParams)
+}
+
+func sessionKeyPassword(password string, salt []byte, kdfParams *KdfParams) ([]byte, error) {
+	return scrypt.Key(
+		[]byte(password),
+		salt,
+		kdfParams.N,
+		kdfParams.R,
+		kdfParams.P,
+		32,
+	)
+}
+
+// NewSessionKeyPK creates a new ACT Session Key using an ECDH shared secret for the given key pair and the given salt value
+func NewSessionKeyPK(private *ecdsa.PrivateKey, public *ecdsa.PublicKey, salt []byte) ([]byte, error) {
+	granteePubEcies := ecies.ImportECDSAPublic(public)
+	privateKey := ecies.ImportECDSA(private)
+
+	bytes, err := privateKey.GenerateShared(granteePubEcies, 16, 16)
+	if err != nil {
+		return nil, err
+	}
+	bytes = append(salt, bytes...)
+	sessionKey := crypto.Keccak256(bytes)
+	return sessionKey, nil
+}
+
+func (a *API) doDecrypt(ctx context.Context, credentials string, pk *ecdsa.PrivateKey) DecryptFunc {
+	return func(m *ManifestEntry) error {
+		if m.Access == nil {
+			return nil
+		}
+
+		allowed := false
+		requestDomain := sctx.GetHost(ctx)
+		for _, v := range AllowedDecryptDomains {
+			if strings.Contains(requestDomain, v) {
+				allowed = true
+			}
+		}
+
+		if !allowed {
+			return ErrDecryptDomainForbidden
+		}
+
+		switch m.Access.Type {
+		case "pass":
+			if credentials != "" {
+				key, err := NewSessionKeyPassword(credentials, m.Access)
+				if err != nil {
+					return err
+				}
+
+				ref, err := hex.DecodeString(m.Hash)
+				if err != nil {
+					return err
+				}
+
+				enc := NewRefEncryption(len(ref) - 8)
+				decodedRef, err := enc.Decrypt(ref, key)
+				if err != nil {
+					return ErrDecrypt
+				}
+
+				m.Hash = hex.EncodeToString(decodedRef)
+				m.Access = nil
+				return nil
+			}
+			return ErrDecrypt
+		case "pk":
+			publisherBytes, err := hex.DecodeString(m.Access.Publisher)
+			if err != nil {
+				return ErrDecrypt
+			}
+			publisher, err := crypto.DecompressPubkey(publisherBytes)
+			if err != nil {
+				return ErrDecrypt
+			}
+			key, err := NewSessionKeyPK(pk, publisher, m.Access.Salt)
+			if err != nil {
+				return ErrDecrypt
+			}
+			ref, err := hex.DecodeString(m.Hash)
+			if err != nil {
+				return err
+			}
+
+			enc := NewRefEncryption(len(ref) - 8)
+			decodedRef, err := enc.Decrypt(ref, key)
+			if err != nil {
+				return ErrDecrypt
+			}
+
+			m.Hash = hex.EncodeToString(decodedRef)
+			m.Access = nil
+			return nil
+		case "act":
+			var (
+				sessionKey []byte
+				err        error
+			)
+
+			publisherBytes, err := hex.DecodeString(m.Access.Publisher)
+			if err != nil {
+				return ErrDecrypt
+			}
+			publisher, err := crypto.DecompressPubkey(publisherBytes)
+			if err != nil {
+				return ErrDecrypt
+			}
+
+			sessionKey, err = NewSessionKeyPK(pk, publisher, m.Access.Salt)
+			if err != nil {
+				return ErrDecrypt
+			}
+
+			found, ciphertext, decryptionKey, err := a.getACTDecryptionKey(ctx, storage.Address(common.Hex2Bytes(m.Access.Act)), sessionKey)
+			if err != nil {
+				return err
+			}
+			if !found {
+				// try to fall back to password
+				if credentials != "" {
+					sessionKey, err = NewSessionKeyPassword(credentials, m.Access)
+					if err != nil {
+						return err
+					}
+					found, ciphertext, decryptionKey, err = a.getACTDecryptionKey(ctx, storage.Address(common.Hex2Bytes(m.Access.Act)), sessionKey)
+					if err != nil {
+						return err
+					}
+					if !found {
+						return ErrDecrypt
+					}
+				} else {
+					return ErrDecrypt
+				}
+			}
+			enc := NewRefEncryption(len(ciphertext) - 8)
+			decodedRef, err := enc.Decrypt(ciphertext, decryptionKey)
+			if err != nil {
+				return ErrDecrypt
+			}
+
+			ref, err := hex.DecodeString(m.Hash)
+			if err != nil {
+				return err
+			}
+
+			enc = NewRefEncryption(len(ref) - 8)
+			decodedMainRef, err := enc.Decrypt(ref, decodedRef)
+			if err != nil {
+				return ErrDecrypt
+			}
+			m.Hash = hex.EncodeToString(decodedMainRef)
+			m.Access = nil
+			return nil
+		}
+		return ErrUnknownAccessType
+	}
+}
+
+func (a *API) getACTDecryptionKey(ctx context.Context, actManifestAddress storage.Address, sessionKey []byte) (found bool, ciphertext, decryptionKey []byte, err error) {
+	hasher := sha3.NewLegacyKeccak256()
+	hasher.Write(append(sessionKey, 0))
+	lookupKey := hasher.Sum(nil)
+	hasher.Reset()
+
+	hasher.Write(append(sessionKey, 1))
+	accessKeyDecryptionKey := hasher.Sum(nil)
+	hasher.Reset()
+
+	lk := hex.EncodeToString(lookupKey)
+	list, err := a.GetManifestList(ctx, NOOPDecrypt, actManifestAddress, lk)
+	if err != nil {
+		return false, nil, nil, err
+	}
+	for _, v := range list.Entries {
+		if v.Path == lk {
+			cipherTextBytes, err := hex.DecodeString(v.Hash)
+			if err != nil {
+				return false, nil, nil, err
+			}
+			return true, cipherTextBytes, accessKeyDecryptionKey, nil
+		}
+	}
+	return false, nil, nil, nil
+}
+
+func GenerateAccessControlManifest(ctx *cli.Context, ref string, accessKey []byte, ae *AccessEntry) (*Manifest, error) {
+	refBytes, err := hex.DecodeString(ref)
+	if err != nil {
+		return nil, err
+	}
+	// encrypt ref with accessKey
+	enc := NewRefEncryption(len(refBytes))
+	encrypted, err := enc.Encrypt(refBytes, accessKey)
+	if err != nil {
+		return nil, err
+	}
+
+	m := &Manifest{
+		Entries: []ManifestEntry{
+			{
+				Hash:        hex.EncodeToString(encrypted),
+				ContentType: ManifestType,
+				ModTime:     time.Now(),
+				Access:      ae,
+			},
+		},
+	}
+
+	return m, nil
+}
+
+// DoPK is a helper function to the CLI API that handles the entire business logic for
+// creating a session key and access entry given the cli context, ec keys and salt
+func DoPK(ctx *cli.Context, privateKey *ecdsa.PrivateKey, granteePublicKey string, salt []byte) (sessionKey []byte, ae *AccessEntry, err error) {
+	if granteePublicKey == "" {
+		return nil, nil, errors.New("need a grantee Public Key")
+	}
+	b, err := hex.DecodeString(granteePublicKey)
+	if err != nil {
+		log.Error("error decoding grantee public key", "err", err)
+		return nil, nil, err
+	}
+
+	granteePub, err := crypto.DecompressPubkey(b)
+	if err != nil {
+		log.Error("error decompressing grantee public key", "err", err)
+		return nil, nil, err
+	}
+
+	sessionKey, err = NewSessionKeyPK(privateKey, granteePub, salt)
+	if err != nil {
+		log.Error("error getting session key", "err", err)
+		return nil, nil, err
+	}
+
+	ae, err = NewAccessEntryPK(hex.EncodeToString(crypto.CompressPubkey(&privateKey.PublicKey)), salt)
+	if err != nil {
+		log.Error("error generating access entry", "err", err)
+		return nil, nil, err
+	}
+
+	return sessionKey, ae, nil
+}
+
+// DoACT is a helper function to the CLI API that handles the entire business logic for
+// creating a access key, access entry and ACT manifest (including uploading it) given the cli context, ec keys, password grantees and salt
+func DoACT(ctx *cli.Context, privateKey *ecdsa.PrivateKey, salt []byte, grantees []string, encryptPasswords []string) (accessKey []byte, ae *AccessEntry, actManifest *Manifest, err error) {
+	if len(grantees) == 0 && len(encryptPasswords) == 0 {
+		return nil, nil, nil, errors.New("did not get any grantee public keys or any encryption passwords")
+	}
+
+	publisherPub := hex.EncodeToString(crypto.CompressPubkey(&privateKey.PublicKey))
+	grantees = append(grantees, publisherPub)
+
+	accessKey = make([]byte, 32)
+	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
+		panic("reading from crypto/rand failed: " + err.Error())
+	}
+	if _, err := io.ReadFull(rand.Reader, accessKey); err != nil {
+		panic("reading from crypto/rand failed: " + err.Error())
+	}
+
+	lookupPathEncryptedAccessKeyMap := make(map[string]string)
+	i := 0
+	for _, v := range grantees {
+		i++
+		if v == "" {
+			return nil, nil, nil, errors.New("need a grantee Public Key")
+		}
+		b, err := hex.DecodeString(v)
+		if err != nil {
+			log.Error("error decoding grantee public key", "err", err)
+			return nil, nil, nil, err
+		}
+
+		granteePub, err := crypto.DecompressPubkey(b)
+		if err != nil {
+			log.Error("error decompressing grantee public key", "err", err)
+			return nil, nil, nil, err
+		}
+		sessionKey, err := NewSessionKeyPK(privateKey, granteePub, salt)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+
+		hasher := sha3.NewLegacyKeccak256()
+		hasher.Write(append(sessionKey, 0))
+		lookupKey := hasher.Sum(nil)
+
+		hasher.Reset()
+		hasher.Write(append(sessionKey, 1))
+
+		accessKeyEncryptionKey := hasher.Sum(nil)
+
+		enc := NewRefEncryption(len(accessKey))
+		encryptedAccessKey, err := enc.Encrypt(accessKey, accessKeyEncryptionKey)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		lookupPathEncryptedAccessKeyMap[hex.EncodeToString(lookupKey)] = hex.EncodeToString(encryptedAccessKey)
+	}
+
+	for _, pass := range encryptPasswords {
+		sessionKey, err := sessionKeyPassword(pass, salt, DefaultKdfParams)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		hasher := sha3.NewLegacyKeccak256()
+		hasher.Write(append(sessionKey, 0))
+		lookupKey := hasher.Sum(nil)
+
+		hasher.Reset()
+		hasher.Write(append(sessionKey, 1))
+
+		accessKeyEncryptionKey := hasher.Sum(nil)
+
+		enc := NewRefEncryption(len(accessKey))
+		encryptedAccessKey, err := enc.Encrypt(accessKey, accessKeyEncryptionKey)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		lookupPathEncryptedAccessKeyMap[hex.EncodeToString(lookupKey)] = hex.EncodeToString(encryptedAccessKey)
+	}
+
+	m := &Manifest{
+		Entries: []ManifestEntry{},
+	}
+
+	for k, v := range lookupPathEncryptedAccessKeyMap {
+		m.Entries = append(m.Entries, ManifestEntry{
+			Path:        k,
+			Hash:        v,
+			ContentType: "text/plain",
+		})
+	}
+
+	ae, err = NewAccessEntryACT(hex.EncodeToString(crypto.CompressPubkey(&privateKey.PublicKey)), salt, "")
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	return accessKey, ae, m, nil
+}
+
+// DoPassword is a helper function to the CLI API that handles the entire business logic for
+// creating a session key and an access entry given the cli context, password and salt.
+// By default - DefaultKdfParams are used as the scrypt params
+func DoPassword(ctx *cli.Context, password string, salt []byte) (sessionKey []byte, ae *AccessEntry, err error) {
+	ae, err = NewAccessEntryPassword(salt, DefaultKdfParams)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sessionKey, err = NewSessionKeyPassword(password, ae)
+	if err != nil {
+		return nil, nil, err
+	}
+	return sessionKey, ae, nil
+}
--- a/api/api.go
+++ b/api/api.go
@ -0,0 +1,993 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+//go:generate mimegen --types=./../../cmd/swarm/mimegen/mime.types --package=api --out=gen_mime.go
+//go:generate gofmt -s -w gen_mime.go
+
+import (
+	"archive/tar"
+	"context"
+	"crypto/ecdsa"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"net/http"
+	"path"
+	"strings"
+
+	"bytes"
+	"mime"
+	"path/filepath"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/contracts/ens"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/spancontext"
+	"github.com/ethersphere/swarm/storage"
+	"github.com/ethersphere/swarm/storage/feed"
+	"github.com/ethersphere/swarm/storage/feed/lookup"
+
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+var (
+	apiResolveCount        = metrics.NewRegisteredCounter("api.resolve.count", nil)
+	apiResolveFail         = metrics.NewRegisteredCounter("api.resolve.fail", nil)
+	apiGetCount            = metrics.NewRegisteredCounter("api.get.count", nil)
+	apiGetNotFound         = metrics.NewRegisteredCounter("api.get.notfound", nil)
+	apiGetHTTP300          = metrics.NewRegisteredCounter("api.get.http.300", nil)
+	apiManifestUpdateCount = metrics.NewRegisteredCounter("api.manifestupdate.count", nil)
+	apiManifestUpdateFail  = metrics.NewRegisteredCounter("api.manifestupdate.fail", nil)
+	apiManifestListCount   = metrics.NewRegisteredCounter("api.manifestlist.count", nil)
+	apiManifestListFail    = metrics.NewRegisteredCounter("api.manifestlist.fail", nil)
+	apiDeleteCount         = metrics.NewRegisteredCounter("api.delete.count", nil)
+	apiDeleteFail          = metrics.NewRegisteredCounter("api.delete.fail", nil)
+	apiGetTarCount         = metrics.NewRegisteredCounter("api.gettar.count", nil)
+	apiGetTarFail          = metrics.NewRegisteredCounter("api.gettar.fail", nil)
+	apiUploadTarCount      = metrics.NewRegisteredCounter("api.uploadtar.count", nil)
+	apiUploadTarFail       = metrics.NewRegisteredCounter("api.uploadtar.fail", nil)
+	apiModifyCount         = metrics.NewRegisteredCounter("api.modify.count", nil)
+	apiModifyFail          = metrics.NewRegisteredCounter("api.modify.fail", nil)
+	apiAddFileCount        = metrics.NewRegisteredCounter("api.addfile.count", nil)
+	apiAddFileFail         = metrics.NewRegisteredCounter("api.addfile.fail", nil)
+	apiRmFileCount         = metrics.NewRegisteredCounter("api.removefile.count", nil)
+	apiRmFileFail          = metrics.NewRegisteredCounter("api.removefile.fail", nil)
+	apiAppendFileCount     = metrics.NewRegisteredCounter("api.appendfile.count", nil)
+	apiAppendFileFail      = metrics.NewRegisteredCounter("api.appendfile.fail", nil)
+	apiGetInvalid          = metrics.NewRegisteredCounter("api.get.invalid", nil)
+)
+
+// Resolver interface resolve a domain name to a hash using ENS
+type Resolver interface {
+	Resolve(string) (common.Hash, error)
+}
+
+// ResolveValidator is used to validate the contained Resolver
+type ResolveValidator interface {
+	Resolver
+	Owner(node [32]byte) (common.Address, error)
+	HeaderByNumber(context.Context, *big.Int) (*types.Header, error)
+}
+
+// NoResolverError is returned by MultiResolver.Resolve if no resolver
+// can be found for the address.
+type NoResolverError struct {
+	TLD string
+}
+
+// NewNoResolverError creates a NoResolverError for the given top level domain
+func NewNoResolverError(tld string) *NoResolverError {
+	return &NoResolverError{TLD: tld}
+}
+
+// Error NoResolverError implements error
+func (e *NoResolverError) Error() string {
+	if e.TLD == "" {
+		return "no ENS resolver"
+	}
+	return fmt.Sprintf("no ENS endpoint configured to resolve .%s TLD names", e.TLD)
+}
+
+// MultiResolver is used to resolve URL addresses based on their TLDs.
+// Each TLD can have multiple resolvers, and the resolution from the
+// first one in the sequence will be returned.
+type MultiResolver struct {
+	resolvers map[string][]ResolveValidator
+	nameHash  func(string) common.Hash
+}
+
+// MultiResolverOption sets options for MultiResolver and is used as
+// arguments for its constructor.
+type MultiResolverOption func(*MultiResolver)
+
+// MultiResolverOptionWithResolver adds a Resolver to a list of resolvers
+// for a specific TLD. If TLD is an empty string, the resolver will be added
+// to the list of default resolver, the ones that will be used for resolution
+// of addresses which do not have their TLD resolver specified.
+func MultiResolverOptionWithResolver(r ResolveValidator, tld string) MultiResolverOption {
+	return func(m *MultiResolver) {
+		m.resolvers[tld] = append(m.resolvers[tld], r)
+	}
+}
+
+// NewMultiResolver creates a new instance of MultiResolver.
+func NewMultiResolver(opts ...MultiResolverOption) (m *MultiResolver) {
+	m = &MultiResolver{
+		resolvers: make(map[string][]ResolveValidator),
+		nameHash:  ens.EnsNode,
+	}
+	for _, o := range opts {
+		o(m)
+	}
+	return m
+}
+
+// Resolve resolves address by choosing a Resolver by TLD.
+// If there are more default Resolvers, or for a specific TLD,
+// the Hash from the first one which does not return error
+// will be returned.
+func (m *MultiResolver) Resolve(addr string) (h common.Hash, err error) {
+	rs, err := m.getResolveValidator(addr)
+	if err != nil {
+		return h, err
+	}
+	for _, r := range rs {
+		h, err = r.Resolve(addr)
+		if err == nil {
+			return
+		}
+	}
+	return
+}
+
+// getResolveValidator uses the hostname to retrieve the resolver associated with the top level domain
+func (m *MultiResolver) getResolveValidator(name string) ([]ResolveValidator, error) {
+	rs := m.resolvers[""]
+	tld := path.Ext(name)
+	if tld != "" {
+		tld = tld[1:]
+		rstld, ok := m.resolvers[tld]
+		if ok {
+			return rstld, nil
+		}
+	}
+	if len(rs) == 0 {
+		return rs, NewNoResolverError(tld)
+	}
+	return rs, nil
+}
+
+/*
+API implements webserver/file system related content storage and retrieval
+on top of the FileStore
+it is the public interface of the FileStore which is included in the ethereum stack
+*/
+type API struct {
+	feed      *feed.Handler
+	fileStore *storage.FileStore
+	dns       Resolver
+	Tags      *chunk.Tags
+	Decryptor func(context.Context, string) DecryptFunc
+}
+
+// NewAPI the api constructor initialises a new API instance.
+func NewAPI(fileStore *storage.FileStore, dns Resolver, feedHandler *feed.Handler, pk *ecdsa.PrivateKey, tags *chunk.Tags) (self *API) {
+	self = &API{
+		fileStore: fileStore,
+		dns:       dns,
+		feed:      feedHandler,
+		Tags:      tags,
+		Decryptor: func(ctx context.Context, credentials string) DecryptFunc {
+			return self.doDecrypt(ctx, credentials, pk)
+		},
+	}
+	return
+}
+
+// Retrieve FileStore reader API
+func (a *API) Retrieve(ctx context.Context, addr storage.Address) (reader storage.LazySectionReader, isEncrypted bool) {
+	return a.fileStore.Retrieve(ctx, addr)
+}
+
+// Store wraps the Store API call of the embedded FileStore
+func (a *API) Store(ctx context.Context, data io.Reader, size int64, toEncrypt bool) (addr storage.Address, wait func(ctx context.Context) error, err error) {
+	log.Debug("api.store", "size", size)
+	return a.fileStore.Store(ctx, data, size, toEncrypt)
+}
+
+// Resolve a name into a content-addressed hash
+// where address could be an ENS name, or a content addressed hash
+func (a *API) Resolve(ctx context.Context, address string) (storage.Address, error) {
+	// if DNS is not configured, return an error
+	if a.dns == nil {
+		if hashMatcher.MatchString(address) {
+			return common.Hex2Bytes(address), nil
+		}
+		apiResolveFail.Inc(1)
+		return nil, fmt.Errorf("no DNS to resolve name: %q", address)
+	}
+	// try and resolve the address
+	resolved, err := a.dns.Resolve(address)
+	if err != nil {
+		if hashMatcher.MatchString(address) {
+			return common.Hex2Bytes(address), nil
+		}
+		return nil, err
+	}
+	return resolved[:], nil
+}
+
+// Resolve resolves a URI to an Address using the MultiResolver.
+func (a *API) ResolveURI(ctx context.Context, uri *URI, credentials string) (storage.Address, error) {
+	apiResolveCount.Inc(1)
+	log.Trace("resolving", "uri", uri.Addr)
+
+	var sp opentracing.Span
+	ctx, sp = spancontext.StartSpan(
+		ctx,
+		"api.resolve")
+	defer sp.Finish()
+
+	// if the URI is immutable, check if the address looks like a hash
+	if uri.Immutable() {
+		key := uri.Address()
+		if key == nil {
+			return nil, fmt.Errorf("immutable address not a content hash: %q", uri.Addr)
+		}
+		return key, nil
+	}
+
+	addr, err := a.Resolve(ctx, uri.Addr)
+	if err != nil {
+		return nil, err
+	}
+
+	if uri.Path == "" {
+		return addr, nil
+	}
+	walker, err := a.NewManifestWalker(ctx, addr, a.Decryptor(ctx, credentials), nil)
+	if err != nil {
+		return nil, err
+	}
+	var entry *ManifestEntry
+	walker.Walk(func(e *ManifestEntry) error {
+		// if the entry matches the path, set entry and stop
+		// the walk
+		if e.Path == uri.Path {
+			entry = e
+			// return an error to cancel the walk
+			return errors.New("found")
+		}
+		// ignore non-manifest files
+		if e.ContentType != ManifestType {
+			return nil
+		}
+		// if the manifest's path is a prefix of the
+		// requested path, recurse into it by returning
+		// nil and continuing the walk
+		if strings.HasPrefix(uri.Path, e.Path) {
+			return nil
+		}
+		return ErrSkipManifest
+	})
+	if entry == nil {
+		return nil, errors.New("not found")
+	}
+	addr = storage.Address(common.Hex2Bytes(entry.Hash))
+	return addr, nil
+}
+
+// Get uses iterative manifest retrieval and prefix matching
+// to resolve basePath to content using FileStore retrieve
+// it returns a section reader, mimeType, status, the key of the actual content and an error
+func (a *API) Get(ctx context.Context, decrypt DecryptFunc, manifestAddr storage.Address, path string) (reader storage.LazySectionReader, mimeType string, status int, contentAddr storage.Address, err error) {
+	log.Debug("api.get", "key", manifestAddr, "path", path)
+	apiGetCount.Inc(1)
+	trie, err := loadManifest(ctx, a.fileStore, manifestAddr, nil, decrypt)
+	if err != nil {
+		apiGetNotFound.Inc(1)
+		status = http.StatusNotFound
+		return nil, "", http.StatusNotFound, nil, err
+	}
+
+	log.Debug("trie getting entry", "key", manifestAddr, "path", path)
+	entry, _ := trie.getEntry(path)
+
+	if entry != nil {
+		log.Debug("trie got entry", "key", manifestAddr, "path", path, "entry.Hash", entry.Hash)
+
+		if entry.ContentType == ManifestType {
+			log.Debug("entry is manifest", "key", manifestAddr, "new key", entry.Hash)
+			adr, err := hex.DecodeString(entry.Hash)
+			if err != nil {
+				return nil, "", 0, nil, err
+			}
+			return a.Get(ctx, decrypt, adr, entry.Path)
+		}
+
+		// we need to do some extra work if this is a Swarm feed manifest
+		if entry.ContentType == FeedContentType {
+			if entry.Feed == nil {
+				return reader, mimeType, status, nil, fmt.Errorf("Cannot decode Feed in manifest")
+			}
+			_, err := a.feed.Lookup(ctx, feed.NewQueryLatest(entry.Feed, lookup.NoClue))
+			if err != nil {
+				apiGetNotFound.Inc(1)
+				status = http.StatusNotFound
+				log.Debug(fmt.Sprintf("get feed update content error: %v", err))
+				return reader, mimeType, status, nil, err
+			}
+			// get the data of the update
+			_, contentAddr, err := a.feed.GetContent(entry.Feed)
+			if err != nil {
+				apiGetNotFound.Inc(1)
+				status = http.StatusNotFound
+				log.Warn(fmt.Sprintf("get feed update content error: %v", err))
+				return reader, mimeType, status, nil, err
+			}
+
+			// extract content hash
+			if len(contentAddr) != storage.AddressLength {
+				apiGetInvalid.Inc(1)
+				status = http.StatusUnprocessableEntity
+				errorMessage := fmt.Sprintf("invalid swarm hash in feed update. Expected %d bytes. Got %d", storage.AddressLength, len(contentAddr))
+				log.Warn(errorMessage)
+				return reader, mimeType, status, nil, errors.New(errorMessage)
+			}
+			manifestAddr = storage.Address(contentAddr)
+			log.Trace("feed update contains swarm hash", "key", manifestAddr)
+
+			// get the manifest the swarm hash points to
+			trie, err := loadManifest(ctx, a.fileStore, manifestAddr, nil, NOOPDecrypt)
+			if err != nil {
+				apiGetNotFound.Inc(1)
+				status = http.StatusNotFound
+				log.Warn(fmt.Sprintf("loadManifestTrie (feed update) error: %v", err))
+				return reader, mimeType, status, nil, err
+			}
+
+			// finally, get the manifest entry
+			// it will always be the entry on path ""
+			entry, _ = trie.getEntry(path)
+			if entry == nil {
+				status = http.StatusNotFound
+				apiGetNotFound.Inc(1)
+				err = fmt.Errorf("manifest (feed update) entry for '%s' not found", path)
+				log.Trace("manifest (feed update) entry not found", "key", manifestAddr, "path", path)
+				return reader, mimeType, status, nil, err
+			}
+		}
+
+		// regardless of feed update manifests or normal manifests we will converge at this point
+		// get the key the manifest entry points to and serve it if it's unambiguous
+		contentAddr = common.Hex2Bytes(entry.Hash)
+		status = entry.Status
+		if status == http.StatusMultipleChoices {
+			apiGetHTTP300.Inc(1)
+			return nil, entry.ContentType, status, contentAddr, err
+		}
+		mimeType = entry.ContentType
+		log.Debug("content lookup key", "key", contentAddr, "mimetype", mimeType)
+		reader, _ = a.fileStore.Retrieve(ctx, contentAddr)
+	} else {
+		// no entry found
+		status = http.StatusNotFound
+		apiGetNotFound.Inc(1)
+		err = fmt.Errorf("Not found: could not find resource '%s'", path)
+		log.Trace("manifest entry not found", "key", contentAddr, "path", path)
+	}
+	return
+}
+
+func (a *API) Delete(ctx context.Context, addr string, path string) (storage.Address, error) {
+	apiDeleteCount.Inc(1)
+	uri, err := Parse("bzz:/" + addr)
+	if err != nil {
+		apiDeleteFail.Inc(1)
+		return nil, err
+	}
+	key, err := a.ResolveURI(ctx, uri, EmptyCredentials)
+
+	if err != nil {
+		return nil, err
+	}
+	newKey, err := a.UpdateManifest(ctx, key, func(mw *ManifestWriter) error {
+		log.Debug(fmt.Sprintf("removing %s from manifest %s", path, key.Log()))
+		return mw.RemoveEntry(path)
+	})
+	if err != nil {
+		apiDeleteFail.Inc(1)
+		return nil, err
+	}
+
+	return newKey, nil
+}
+
+// GetDirectoryTar fetches a requested directory as a tarstream
+// it returns an io.Reader and an error. Do not forget to Close() the returned ReadCloser
+func (a *API) GetDirectoryTar(ctx context.Context, decrypt DecryptFunc, uri *URI) (io.ReadCloser, error) {
+	apiGetTarCount.Inc(1)
+	addr, err := a.Resolve(ctx, uri.Addr)
+	if err != nil {
+		return nil, err
+	}
+	walker, err := a.NewManifestWalker(ctx, addr, decrypt, nil)
+	if err != nil {
+		apiGetTarFail.Inc(1)
+		return nil, err
+	}
+
+	piper, pipew := io.Pipe()
+
+	tw := tar.NewWriter(pipew)
+
+	go func() {
+		err := walker.Walk(func(entry *ManifestEntry) error {
+			// ignore manifests (walk will recurse into them)
+			if entry.ContentType == ManifestType {
+				return nil
+			}
+
+			// retrieve the entry's key and size
+			reader, _ := a.Retrieve(ctx, storage.Address(common.Hex2Bytes(entry.Hash)))
+			size, err := reader.Size(ctx, nil)
+			if err != nil {
+				return err
+			}
+
+			// write a tar header for the entry
+			hdr := &tar.Header{
+				Name:    entry.Path,
+				Mode:    entry.Mode,
+				Size:    size,
+				ModTime: entry.ModTime,
+				Xattrs: map[string]string{
+					"user.swarm.content-type": entry.ContentType,
+				},
+			}
+
+			if err := tw.WriteHeader(hdr); err != nil {
+				return err
+			}
+
+			// copy the file into the tar stream
+			n, err := io.Copy(tw, io.LimitReader(reader, hdr.Size))
+			if err != nil {
+				return err
+			} else if n != size {
+				return fmt.Errorf("error writing %s: expected %d bytes but sent %d", entry.Path, size, n)
+			}
+
+			return nil
+		})
+		// close tar writer before closing pipew
+		// to flush remaining data to pipew
+		// regardless of error value
+		tw.Close()
+		if err != nil {
+			apiGetTarFail.Inc(1)
+			pipew.CloseWithError(err)
+		} else {
+			pipew.Close()
+		}
+	}()
+
+	return piper, nil
+}
+
+// GetManifestList lists the manifest entries for the specified address and prefix
+// and returns it as a ManifestList
+func (a *API) GetManifestList(ctx context.Context, decryptor DecryptFunc, addr storage.Address, prefix string) (list ManifestList, err error) {
+	apiManifestListCount.Inc(1)
+	walker, err := a.NewManifestWalker(ctx, addr, decryptor, nil)
+	if err != nil {
+		apiManifestListFail.Inc(1)
+		return ManifestList{}, err
+	}
+
+	err = walker.Walk(func(entry *ManifestEntry) error {
+		// handle non-manifest files
+		if entry.ContentType != ManifestType {
+			// ignore the file if it doesn't have the specified prefix
+			if !strings.HasPrefix(entry.Path, prefix) {
+				return nil
+			}
+
+			// if the path after the prefix contains a slash, add a
+			// common prefix to the list, otherwise add the entry
+			suffix := strings.TrimPrefix(entry.Path, prefix)
+			if index := strings.Index(suffix, "/"); index > -1 {
+				list.CommonPrefixes = append(list.CommonPrefixes, prefix+suffix[:index+1])
+				return nil
+			}
+			if entry.Path == "" {
+				entry.Path = "/"
+			}
+			list.Entries = append(list.Entries, entry)
+			return nil
+		}
+
+		// if the manifest's path is a prefix of the specified prefix
+		// then just recurse into the manifest by returning nil and
+		// continuing the walk
+		if strings.HasPrefix(prefix, entry.Path) {
+			return nil
+		}
+
+		// if the manifest's path has the specified prefix, then if the
+		// path after the prefix contains a slash, add a common prefix
+		// to the list and skip the manifest, otherwise recurse into
+		// the manifest by returning nil and continuing the walk
+		if strings.HasPrefix(entry.Path, prefix) {
+			suffix := strings.TrimPrefix(entry.Path, prefix)
+			if index := strings.Index(suffix, "/"); index > -1 {
+				list.CommonPrefixes = append(list.CommonPrefixes, prefix+suffix[:index+1])
+				return ErrSkipManifest
+			}
+			return nil
+		}
+
+		// the manifest neither has the prefix or needs recursing in to
+		// so just skip it
+		return ErrSkipManifest
+	})
+
+	if err != nil {
+		apiManifestListFail.Inc(1)
+		return ManifestList{}, err
+	}
+
+	return list, nil
+}
+
+func (a *API) UpdateManifest(ctx context.Context, addr storage.Address, update func(mw *ManifestWriter) error) (storage.Address, error) {
+	apiManifestUpdateCount.Inc(1)
+	mw, err := a.NewManifestWriter(ctx, addr, nil)
+	if err != nil {
+		apiManifestUpdateFail.Inc(1)
+		return nil, err
+	}
+
+	if err := update(mw); err != nil {
+		apiManifestUpdateFail.Inc(1)
+		return nil, err
+	}
+
+	addr, err = mw.Store()
+	if err != nil {
+		apiManifestUpdateFail.Inc(1)
+		return nil, err
+	}
+	log.Debug(fmt.Sprintf("generated manifest %s", addr))
+	return addr, nil
+}
+
+// Modify loads manifest and checks the content hash before recalculating and storing the manifest.
+func (a *API) Modify(ctx context.Context, addr storage.Address, path, contentHash, contentType string) (storage.Address, error) {
+	apiModifyCount.Inc(1)
+	quitC := make(chan bool)
+	trie, err := loadManifest(ctx, a.fileStore, addr, quitC, NOOPDecrypt)
+	if err != nil {
+		apiModifyFail.Inc(1)
+		return nil, err
+	}
+	if contentHash != "" {
+		entry := newManifestTrieEntry(&ManifestEntry{
+			Path:        path,
+			ContentType: contentType,
+		}, nil)
+		entry.Hash = contentHash
+		trie.addEntry(entry, quitC)
+	} else {
+		trie.deleteEntry(path, quitC)
+	}
+
+	if err := trie.recalcAndStore(); err != nil {
+		apiModifyFail.Inc(1)
+		return nil, err
+	}
+	return trie.ref, nil
+}
+
+// AddFile creates a new manifest entry, adds it to swarm, then adds a file to swarm.
+func (a *API) AddFile(ctx context.Context, mhash, path, fname string, content []byte, nameresolver bool) (storage.Address, string, error) {
+	apiAddFileCount.Inc(1)
+
+	uri, err := Parse("bzz:/" + mhash)
+	if err != nil {
+		apiAddFileFail.Inc(1)
+		return nil, "", err
+	}
+	mkey, err := a.ResolveURI(ctx, uri, EmptyCredentials)
+	if err != nil {
+		apiAddFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	// trim the root dir we added
+	if path[:1] == "/" {
+		path = path[1:]
+	}
+
+	entry := &ManifestEntry{
+		Path:        filepath.Join(path, fname),
+		ContentType: mime.TypeByExtension(filepath.Ext(fname)),
+		Mode:        0700,
+		Size:        int64(len(content)),
+		ModTime:     time.Now(),
+	}
+
+	mw, err := a.NewManifestWriter(ctx, mkey, nil)
+	if err != nil {
+		apiAddFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	fkey, err := mw.AddEntry(ctx, bytes.NewReader(content), entry)
+	if err != nil {
+		apiAddFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	newMkey, err := mw.Store()
+	if err != nil {
+		apiAddFileFail.Inc(1)
+		return nil, "", err
+
+	}
+
+	return fkey, newMkey.String(), nil
+}
+
+func (a *API) UploadTar(ctx context.Context, bodyReader io.ReadCloser, manifestPath, defaultPath string, mw *ManifestWriter) (storage.Address, error) {
+	apiUploadTarCount.Inc(1)
+	var contentKey storage.Address
+	tr := tar.NewReader(bodyReader)
+	defer bodyReader.Close()
+	var defaultPathFound bool
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			break
+		} else if err != nil {
+			apiUploadTarFail.Inc(1)
+			return nil, fmt.Errorf("error reading tar stream: %s", err)
+		}
+
+		// only store regular files
+		if !hdr.FileInfo().Mode().IsRegular() {
+			continue
+		}
+
+		// add the entry under the path from the request
+		manifestPath := path.Join(manifestPath, hdr.Name)
+		contentType := hdr.Xattrs["user.swarm.content-type"]
+		if contentType == "" {
+			contentType = mime.TypeByExtension(filepath.Ext(hdr.Name))
+		}
+		//DetectContentType("")
+		entry := &ManifestEntry{
+			Path:        manifestPath,
+			ContentType: contentType,
+			Mode:        hdr.Mode,
+			Size:        hdr.Size,
+			ModTime:     hdr.ModTime,
+		}
+		contentKey, err = mw.AddEntry(ctx, tr, entry)
+		if err != nil {
+			apiUploadTarFail.Inc(1)
+			return nil, fmt.Errorf("error adding manifest entry from tar stream: %s", err)
+		}
+		if hdr.Name == defaultPath {
+			contentType := hdr.Xattrs["user.swarm.content-type"]
+			if contentType == "" {
+				contentType = mime.TypeByExtension(filepath.Ext(hdr.Name))
+			}
+
+			entry := &ManifestEntry{
+				Hash:        contentKey.Hex(),
+				Path:        "", // default entry
+				ContentType: contentType,
+				Mode:        hdr.Mode,
+				Size:        hdr.Size,
+				ModTime:     hdr.ModTime,
+			}
+			contentKey, err = mw.AddEntry(ctx, nil, entry)
+			if err != nil {
+				apiUploadTarFail.Inc(1)
+				return nil, fmt.Errorf("error adding default manifest entry from tar stream: %s", err)
+			}
+			defaultPathFound = true
+		}
+	}
+	if defaultPath != "" && !defaultPathFound {
+		return contentKey, fmt.Errorf("default path %q not found", defaultPath)
+	}
+	return contentKey, nil
+}
+
+// RemoveFile removes a file entry in a manifest.
+func (a *API) RemoveFile(ctx context.Context, mhash string, path string, fname string, nameresolver bool) (string, error) {
+	apiRmFileCount.Inc(1)
+
+	uri, err := Parse("bzz:/" + mhash)
+	if err != nil {
+		apiRmFileFail.Inc(1)
+		return "", err
+	}
+	mkey, err := a.ResolveURI(ctx, uri, EmptyCredentials)
+	if err != nil {
+		apiRmFileFail.Inc(1)
+		return "", err
+	}
+
+	// trim the root dir we added
+	if path[:1] == "/" {
+		path = path[1:]
+	}
+
+	mw, err := a.NewManifestWriter(ctx, mkey, nil)
+	if err != nil {
+		apiRmFileFail.Inc(1)
+		return "", err
+	}
+
+	err = mw.RemoveEntry(filepath.Join(path, fname))
+	if err != nil {
+		apiRmFileFail.Inc(1)
+		return "", err
+	}
+
+	newMkey, err := mw.Store()
+	if err != nil {
+		apiRmFileFail.Inc(1)
+		return "", err
+
+	}
+
+	return newMkey.String(), nil
+}
+
+// AppendFile removes old manifest, appends file entry to new manifest and adds it to Swarm.
+func (a *API) AppendFile(ctx context.Context, mhash, path, fname string, existingSize int64, content []byte, oldAddr storage.Address, offset int64, addSize int64, nameresolver bool) (storage.Address, string, error) {
+	apiAppendFileCount.Inc(1)
+
+	buffSize := offset + addSize
+	if buffSize < existingSize {
+		buffSize = existingSize
+	}
+
+	buf := make([]byte, buffSize)
+
+	oldReader, _ := a.Retrieve(ctx, oldAddr)
+	io.ReadAtLeast(oldReader, buf, int(offset))
+
+	newReader := bytes.NewReader(content)
+	io.ReadAtLeast(newReader, buf[offset:], int(addSize))
+
+	if buffSize < existingSize {
+		io.ReadAtLeast(oldReader, buf[addSize:], int(buffSize))
+	}
+
+	combinedReader := bytes.NewReader(buf)
+	totalSize := int64(len(buf))
+
+	// TODO(jmozah): to append using pyramid chunker when it is ready
+	//oldReader := a.Retrieve(oldKey)
+	//newReader := bytes.NewReader(content)
+	//combinedReader := io.MultiReader(oldReader, newReader)
+
+	uri, err := Parse("bzz:/" + mhash)
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+	}
+	mkey, err := a.ResolveURI(ctx, uri, EmptyCredentials)
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	// trim the root dir we added
+	if path[:1] == "/" {
+		path = path[1:]
+	}
+
+	mw, err := a.NewManifestWriter(ctx, mkey, nil)
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	err = mw.RemoveEntry(filepath.Join(path, fname))
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	entry := &ManifestEntry{
+		Path:        filepath.Join(path, fname),
+		ContentType: mime.TypeByExtension(filepath.Ext(fname)),
+		Mode:        0700,
+		Size:        totalSize,
+		ModTime:     time.Now(),
+	}
+
+	fkey, err := mw.AddEntry(ctx, io.Reader(combinedReader), entry)
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+	}
+
+	newMkey, err := mw.Store()
+	if err != nil {
+		apiAppendFileFail.Inc(1)
+		return nil, "", err
+
+	}
+
+	return fkey, newMkey.String(), nil
+}
+
+// BuildDirectoryTree used by swarmfs_unix
+func (a *API) BuildDirectoryTree(ctx context.Context, mhash string, nameresolver bool) (addr storage.Address, manifestEntryMap map[string]*manifestTrieEntry, err error) {
+
+	uri, err := Parse("bzz:/" + mhash)
+	if err != nil {
+		return nil, nil, err
+	}
+	addr, err = a.Resolve(ctx, uri.Addr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	quitC := make(chan bool)
+	rootTrie, err := loadManifest(ctx, a.fileStore, addr, quitC, NOOPDecrypt)
+	if err != nil {
+		return nil, nil, fmt.Errorf("can't load manifest %v: %v", addr.String(), err)
+	}
+
+	manifestEntryMap = map[string]*manifestTrieEntry{}
+	err = rootTrie.listWithPrefix(uri.Path, quitC, func(entry *manifestTrieEntry, suffix string) {
+		manifestEntryMap[suffix] = entry
+	})
+
+	if err != nil {
+		return nil, nil, fmt.Errorf("list with prefix failed %v: %v", addr.String(), err)
+	}
+	return addr, manifestEntryMap, nil
+}
+
+// FeedsLookup finds Swarm feeds updates at specific points in time, or the latest update
+func (a *API) FeedsLookup(ctx context.Context, query *feed.Query) ([]byte, error) {
+	_, err := a.feed.Lookup(ctx, query)
+	if err != nil {
+		return nil, err
+	}
+	var data []byte
+	_, data, err = a.feed.GetContent(&query.Feed)
+	if err != nil {
+		return nil, err
+	}
+	return data, nil
+}
+
+// FeedsNewRequest creates a Request object to update a specific feed
+func (a *API) FeedsNewRequest(ctx context.Context, feed *feed.Feed) (*feed.Request, error) {
+	return a.feed.NewRequest(ctx, feed)
+}
+
+// FeedsUpdate publishes a new update on the given feed
+func (a *API) FeedsUpdate(ctx context.Context, request *feed.Request) (storage.Address, error) {
+	return a.feed.Update(ctx, request)
+}
+
+// ErrCannotLoadFeedManifest is returned when looking up a feeds manifest fails
+var ErrCannotLoadFeedManifest = errors.New("Cannot load feed manifest")
+
+// ErrNotAFeedManifest is returned when the address provided returned something other than a valid manifest
+var ErrNotAFeedManifest = errors.New("Not a feed manifest")
+
+// ResolveFeedManifest retrieves the Swarm feed manifest for the given address, and returns the referenced Feed.
+func (a *API) ResolveFeedManifest(ctx context.Context, addr storage.Address) (*feed.Feed, error) {
+	trie, err := loadManifest(ctx, a.fileStore, addr, nil, NOOPDecrypt)
+	if err != nil {
+		return nil, ErrCannotLoadFeedManifest
+	}
+
+	entry, _ := trie.getEntry("")
+	if entry.ContentType != FeedContentType {
+		return nil, ErrNotAFeedManifest
+	}
+
+	return entry.Feed, nil
+}
+
+// ErrCannotResolveFeedURI is returned when the ENS resolver is not able to translate a name to a Swarm feed
+var ErrCannotResolveFeedURI = errors.New("Cannot resolve Feed URI")
+
+// ErrCannotResolveFeed is returned when values provided are not enough or invalid to recreate a
+// feed out of them.
+var ErrCannotResolveFeed = errors.New("Cannot resolve Feed")
+
+// ResolveFeed attempts to extract feed information out of the manifest, if provided
+// If not, it attempts to extract the feed out of a set of key-value pairs
+func (a *API) ResolveFeed(ctx context.Context, uri *URI, values feed.Values) (*feed.Feed, error) {
+	var fd *feed.Feed
+	var err error
+	if uri.Addr != "" {
+		// resolve the content key.
+		manifestAddr := uri.Address()
+		if manifestAddr == nil {
+			manifestAddr, err = a.Resolve(ctx, uri.Addr)
+			if err != nil {
+				return nil, ErrCannotResolveFeedURI
+			}
+		}
+
+		// get the Swarm feed from the manifest
+		fd, err = a.ResolveFeedManifest(ctx, manifestAddr)
+		if err != nil {
+			return nil, err
+		}
+		log.Debug("handle.get.feed: resolved", "manifestkey", manifestAddr, "feed", fd.Hex())
+	} else {
+		var f feed.Feed
+		if err := f.FromValues(values); err != nil {
+			return nil, ErrCannotResolveFeed
+
+		}
+		fd = &f
+	}
+	return fd, nil
+}
+
+// MimeOctetStream default value of http Content-Type header
+const MimeOctetStream = "application/octet-stream"
+
+// DetectContentType by file file extension, or fallback to content sniff
+func DetectContentType(fileName string, f io.ReadSeeker) (string, error) {
+	ctype := mime.TypeByExtension(filepath.Ext(fileName))
+	if ctype != "" {
+		return ctype, nil
+	}
+
+	// save/rollback to get content probe from begin of file
+	currentPosition, err := f.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return MimeOctetStream, fmt.Errorf("seeker can't seek, %s", err)
+	}
+
+	// read a chunk to decide between utf-8 text and binary
+	var buf [512]byte
+	n, _ := f.Read(buf[:])
+	ctype = http.DetectContentType(buf[:n])
+
+	_, err = f.Seek(currentPosition, io.SeekStart) // rewind to output whole file
+	if err != nil {
+		return MimeOctetStream, fmt.Errorf("seeker can't seek, %s", err)
+	}
+
+	return ctype, nil
+}
--- a/api/api_test.go
+++ b/api/api_test.go
@ -0,0 +1,577 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"bytes"
+	"context"
+	crand "crypto/rand"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/big"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/sctx"
+	"github.com/ethersphere/swarm/storage"
+	"github.com/ethersphere/swarm/testutil"
+)
+
+func init() {
+	loglevel := flag.Int("loglevel", 2, "loglevel")
+	flag.Parse()
+	log.Root().SetHandler(log.CallerFileHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(os.Stderr, log.TerminalFormat(true)))))
+}
+
+func testAPI(t *testing.T, f func(*API, *chunk.Tags, bool)) {
+	for _, v := range []bool{true, false} {
+		datadir, err := ioutil.TempDir("", "bzz-test")
+		if err != nil {
+			t.Fatalf("unable to create temp dir: %v", err)
+		}
+		defer os.RemoveAll(datadir)
+		tags := chunk.NewTags()
+		fileStore, cleanup, err := storage.NewLocalFileStore(datadir, make([]byte, 32), tags)
+		if err != nil {
+			return
+		}
+		defer cleanup()
+		api := NewAPI(fileStore, nil, nil, nil, tags)
+		f(api, tags, v)
+	}
+}
+
+type testResponse struct {
+	reader storage.LazySectionReader
+	*Response
+}
+
+type Response struct {
+	MimeType string
+	Status   int
+	Size     int64
+	Content  string
+}
+
+func checkResponse(t *testing.T, resp *testResponse, exp *Response) {
+
+	if resp.MimeType != exp.MimeType {
+		t.Errorf("incorrect mimeType. expected '%s', got '%s'", exp.MimeType, resp.MimeType)
+	}
+	if resp.Status != exp.Status {
+		t.Errorf("incorrect status. expected '%d', got '%d'", exp.Status, resp.Status)
+	}
+	if resp.Size != exp.Size {
+		t.Errorf("incorrect size. expected '%d', got '%d'", exp.Size, resp.Size)
+	}
+	if resp.reader != nil {
+		content := make([]byte, resp.Size)
+		read, _ := resp.reader.Read(content)
+		if int64(read) != exp.Size {
+			t.Errorf("incorrect content length. expected '%d...', got '%d...'", read, exp.Size)
+		}
+		resp.Content = string(content)
+	}
+	if resp.Content != exp.Content {
+		// if !bytes.Equal(resp.Content, exp.Content)
+		t.Errorf("incorrect content. expected '%s...', got '%s...'", string(exp.Content), string(resp.Content))
+	}
+}
+
+// func expResponse(content []byte, mimeType string, status int) *Response {
+func expResponse(content string, mimeType string, status int) *Response {
+	log.Trace(fmt.Sprintf("expected content (%v): %v ", len(content), content))
+	return &Response{mimeType, status, int64(len(content)), content}
+}
+
+func testGet(t *testing.T, api *API, bzzhash, path string) *testResponse {
+	addr := storage.Address(common.Hex2Bytes(bzzhash))
+	reader, mimeType, status, _, err := api.Get(context.TODO(), NOOPDecrypt, addr, path)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	quitC := make(chan bool)
+	size, err := reader.Size(context.TODO(), quitC)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	log.Trace(fmt.Sprintf("reader size: %v ", size))
+	s := make([]byte, size)
+	_, err = reader.Read(s)
+	if err != io.EOF {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	reader.Seek(0, 0)
+	return &testResponse{reader, &Response{mimeType, status, size, string(s)}}
+}
+
+func TestApiPut(t *testing.T) {
+	testAPI(t, func(api *API, tags *chunk.Tags, toEncrypt bool) {
+		content := "hello"
+		exp := expResponse(content, "text/plain", 0)
+		ctx := context.TODO()
+		addr, wait, err := putString(ctx, api, content, exp.MimeType, toEncrypt)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		err = wait(ctx)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		resp := testGet(t, api, addr.Hex(), "")
+		checkResponse(t, resp, exp)
+		tag := tags.All()[0]
+		testutil.CheckTag(t, tag, 2, 2, 0, 2) //1 chunk data, 1 chunk manifest
+	})
+}
+
+// TestApiTagLarge tests that the the number of chunks counted is larger for a larger input
+func TestApiTagLarge(t *testing.T) {
+	const contentLength = 4096 * 4095
+	testAPI(t, func(api *API, tags *chunk.Tags, toEncrypt bool) {
+		randomContentReader := io.LimitReader(crand.Reader, int64(contentLength))
+		tag, err := api.Tags.New("unnamed-tag", 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ctx := sctx.SetTag(context.Background(), tag.Uid)
+		key, waitContent, err := api.Store(ctx, randomContentReader, int64(contentLength), toEncrypt)
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = waitContent(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		tag.DoneSplit(key)
+
+		if toEncrypt {
+			tag := tags.All()[0]
+			expect := int64(4095 + 64 + 1)
+			testutil.CheckTag(t, tag, expect, expect, 0, expect)
+		} else {
+			tag := tags.All()[0]
+			expect := int64(4095 + 32 + 1)
+			testutil.CheckTag(t, tag, expect, expect, 0, expect)
+		}
+	})
+}
+
+// testResolver implements the Resolver interface and either returns the given
+// hash if it is set, or returns a "name not found" error
+type testResolveValidator struct {
+	hash *common.Hash
+}
+
+func newTestResolveValidator(addr string) *testResolveValidator {
+	r := &testResolveValidator{}
+	if addr != "" {
+		hash := common.HexToHash(addr)
+		r.hash = &hash
+	}
+	return r
+}
+
+func (t *testResolveValidator) Resolve(addr string) (common.Hash, error) {
+	if t.hash == nil {
+		return common.Hash{}, fmt.Errorf("DNS name not found: %q", addr)
+	}
+	return *t.hash, nil
+}
+
+func (t *testResolveValidator) Owner(node [32]byte) (addr common.Address, err error) {
+	return
+}
+func (t *testResolveValidator) HeaderByNumber(context.Context, *big.Int) (header *types.Header, err error) {
+	return
+}
+
+// TestAPIResolve tests resolving URIs which can either contain content hashes
+// or ENS names
+func TestAPIResolve(t *testing.T) {
+	ensAddr := "swarm.eth"
+	hashAddr := "1111111111111111111111111111111111111111111111111111111111111111"
+	resolvedAddr := "2222222222222222222222222222222222222222222222222222222222222222"
+	doesResolve := newTestResolveValidator(resolvedAddr)
+	doesntResolve := newTestResolveValidator("")
+
+	type test struct {
+		desc      string
+		dns       Resolver
+		addr      string
+		immutable bool
+		result    string
+		expectErr error
+	}
+
+	tests := []*test{
+		{
+			desc:   "DNS not configured, hash address, returns hash address",
+			dns:    nil,
+			addr:   hashAddr,
+			result: hashAddr,
+		},
+		{
+			desc:      "DNS not configured, ENS address, returns error",
+			dns:       nil,
+			addr:      ensAddr,
+			expectErr: errors.New(`no DNS to resolve name: "swarm.eth"`),
+		},
+		{
+			desc:   "DNS configured, hash address, hash resolves, returns resolved address",
+			dns:    doesResolve,
+			addr:   hashAddr,
+			result: resolvedAddr,
+		},
+		{
+			desc:      "DNS configured, immutable hash address, hash resolves, returns hash address",
+			dns:       doesResolve,
+			addr:      hashAddr,
+			immutable: true,
+			result:    hashAddr,
+		},
+		{
+			desc:   "DNS configured, hash address, hash doesn't resolve, returns hash address",
+			dns:    doesntResolve,
+			addr:   hashAddr,
+			result: hashAddr,
+		},
+		{
+			desc:   "DNS configured, ENS address, name resolves, returns resolved address",
+			dns:    doesResolve,
+			addr:   ensAddr,
+			result: resolvedAddr,
+		},
+		{
+			desc:      "DNS configured, immutable ENS address, name resolves, returns error",
+			dns:       doesResolve,
+			addr:      ensAddr,
+			immutable: true,
+			expectErr: errors.New(`immutable address not a content hash: "swarm.eth"`),
+		},
+		{
+			desc:      "DNS configured, ENS address, name doesn't resolve, returns error",
+			dns:       doesntResolve,
+			addr:      ensAddr,
+			expectErr: errors.New(`DNS name not found: "swarm.eth"`),
+		},
+	}
+	for _, x := range tests {
+		t.Run(x.desc, func(t *testing.T) {
+			api := &API{dns: x.dns}
+			uri := &URI{Addr: x.addr, Scheme: "bzz"}
+			if x.immutable {
+				uri.Scheme = "bzz-immutable"
+			}
+			res, err := api.ResolveURI(context.TODO(), uri, "")
+			if err == nil {
+				if x.expectErr != nil {
+					t.Fatalf("expected error %q, got result %q", x.expectErr, res)
+				}
+				if res.String() != x.result {
+					t.Fatalf("expected result %q, got %q", x.result, res)
+				}
+			} else {
+				if x.expectErr == nil {
+					t.Fatalf("expected no error, got %q", err)
+				}
+				if err.Error() != x.expectErr.Error() {
+					t.Fatalf("expected error %q, got %q", x.expectErr, err)
+				}
+			}
+		})
+	}
+}
+
+func TestMultiResolver(t *testing.T) {
+	doesntResolve := newTestResolveValidator("")
+
+	ethAddr := "swarm.eth"
+	ethHash := "0x2222222222222222222222222222222222222222222222222222222222222222"
+	ethResolve := newTestResolveValidator(ethHash)
+
+	testAddr := "swarm.test"
+	testHash := "0x1111111111111111111111111111111111111111111111111111111111111111"
+	testResolve := newTestResolveValidator(testHash)
+
+	tests := []struct {
+		desc   string
+		r      Resolver
+		addr   string
+		result string
+		err    error
+	}{
+		{
+			desc: "No resolvers, returns error",
+			r:    NewMultiResolver(),
+			err:  NewNoResolverError(""),
+		},
+		{
+			desc:   "One default resolver, returns resolved address",
+			r:      NewMultiResolver(MultiResolverOptionWithResolver(ethResolve, "")),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "Two default resolvers, returns resolved address",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(ethResolve, ""),
+				MultiResolverOptionWithResolver(ethResolve, ""),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "Two default resolvers, first doesn't resolve, returns resolved address",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(doesntResolve, ""),
+				MultiResolverOptionWithResolver(ethResolve, ""),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "Default resolver doesn't resolve, tld resolver resolve, returns resolved address",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(doesntResolve, ""),
+				MultiResolverOptionWithResolver(ethResolve, "eth"),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "Three TLD resolvers, third resolves, returns resolved address",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(doesntResolve, "eth"),
+				MultiResolverOptionWithResolver(doesntResolve, "eth"),
+				MultiResolverOptionWithResolver(ethResolve, "eth"),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "One TLD resolver doesn't resolve, returns error",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(doesntResolve, ""),
+				MultiResolverOptionWithResolver(ethResolve, "eth"),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+		},
+		{
+			desc: "One defautl and one TLD resolver, all doesn't resolve, returns error",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(doesntResolve, ""),
+				MultiResolverOptionWithResolver(doesntResolve, "eth"),
+			),
+			addr:   ethAddr,
+			result: ethHash,
+			err:    errors.New(`DNS name not found: "swarm.eth"`),
+		},
+		{
+			desc: "Two TLD resolvers, both resolve, returns resolved address",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(ethResolve, "eth"),
+				MultiResolverOptionWithResolver(testResolve, "test"),
+			),
+			addr:   testAddr,
+			result: testHash,
+		},
+		{
+			desc: "One TLD resolver, no default resolver, returns error for different TLD",
+			r: NewMultiResolver(
+				MultiResolverOptionWithResolver(ethResolve, "eth"),
+			),
+			addr: testAddr,
+			err:  NewNoResolverError("test"),
+		},
+	}
+	for _, x := range tests {
+		t.Run(x.desc, func(t *testing.T) {
+			res, err := x.r.Resolve(x.addr)
+			if err == nil {
+				if x.err != nil {
+					t.Fatalf("expected error %q, got result %q", x.err, res.Hex())
+				}
+				if res.Hex() != x.result {
+					t.Fatalf("expected result %q, got %q", x.result, res.Hex())
+				}
+			} else {
+				if x.err == nil {
+					t.Fatalf("expected no error, got %q", err)
+				}
+				if err.Error() != x.err.Error() {
+					t.Fatalf("expected error %q, got %q", x.err, err)
+				}
+			}
+		})
+	}
+}
+
+func TestDecryptOriginForbidden(t *testing.T) {
+	ctx := context.TODO()
+	ctx = sctx.SetHost(ctx, "swarm-gateways.net")
+
+	me := &ManifestEntry{
+		Access: &AccessEntry{Type: AccessTypePass},
+	}
+
+	api := NewAPI(nil, nil, nil, nil, chunk.NewTags())
+
+	f := api.Decryptor(ctx, "")
+	err := f(me)
+	if err != ErrDecryptDomainForbidden {
+		t.Fatalf("should fail with ErrDecryptDomainForbidden, got %v", err)
+	}
+}
+
+func TestDecryptOrigin(t *testing.T) {
+	for _, v := range []struct {
+		host        string
+		expectError error
+	}{
+		{
+			host:        "localhost",
+			expectError: ErrDecrypt,
+		},
+		{
+			host:        "127.0.0.1",
+			expectError: ErrDecrypt,
+		},
+		{
+			host:        "swarm-gateways.net",
+			expectError: ErrDecryptDomainForbidden,
+		},
+	} {
+		ctx := context.TODO()
+		ctx = sctx.SetHost(ctx, v.host)
+
+		me := &ManifestEntry{
+			Access: &AccessEntry{Type: AccessTypePass},
+		}
+
+		api := NewAPI(nil, nil, nil, nil, chunk.NewTags())
+
+		f := api.Decryptor(ctx, "")
+		err := f(me)
+		if err != v.expectError {
+			t.Fatalf("should fail with %v, got %v", v.expectError, err)
+		}
+	}
+}
+
+func TestDetectContentType(t *testing.T) {
+	for _, tc := range []struct {
+		file                string
+		content             string
+		expectedContentType string
+	}{
+		{
+			file:                "file-with-correct-css.css",
+			content:             "body {background-color: orange}",
+			expectedContentType: "text/css; charset=utf-8",
+		},
+		{
+			file:                "empty-file.css",
+			content:             "",
+			expectedContentType: "text/css; charset=utf-8",
+		},
+		{
+			file:                "empty-file.pdf",
+			content:             "",
+			expectedContentType: "application/pdf",
+		},
+		{
+			file:                "empty-file.md",
+			content:             "",
+			expectedContentType: "text/markdown; charset=utf-8",
+		},
+		{
+			file:                "empty-file-with-unknown-content.strangeext",
+			content:             "",
+			expectedContentType: "text/plain; charset=utf-8",
+		},
+		{
+			file:                "file-with-unknown-extension-and-content.strangeext",
+			content:             "Lorem Ipsum",
+			expectedContentType: "text/plain; charset=utf-8",
+		},
+		{
+			file:                "file-no-extension",
+			content:             "Lorem Ipsum",
+			expectedContentType: "text/plain; charset=utf-8",
+		},
+		{
+			file:                "file-no-extension-no-content",
+			content:             "",
+			expectedContentType: "text/plain; charset=utf-8",
+		},
+		{
+			file:                "css-file-with-html-inside.css",
+			content:             "<!doctype html><html><head></head><body></body></html>",
+			expectedContentType: "text/css; charset=utf-8",
+		},
+	} {
+		t.Run(tc.file, func(t *testing.T) {
+			detected, err := DetectContentType(tc.file, bytes.NewReader([]byte(tc.content)))
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if detected != tc.expectedContentType {
+				t.Fatalf("File: %s, Expected mime type %s, got %s", tc.file, tc.expectedContentType, detected)
+			}
+
+		})
+	}
+}
+
+// putString provides singleton manifest creation on top of api.API
+func putString(ctx context.Context, a *API, content string, contentType string, toEncrypt bool) (k storage.Address, wait func(context.Context) error, err error) {
+	r := strings.NewReader(content)
+	tag, err := a.Tags.New("unnamed-tag", 0)
+
+	log.Trace("created new tag", "uid", tag.Uid)
+
+	cCtx := sctx.SetTag(ctx, tag.Uid)
+	key, waitContent, err := a.Store(cCtx, r, int64(len(content)), toEncrypt)
+	if err != nil {
+		return nil, nil, err
+	}
+	manifest := fmt.Sprintf(`{"entries":[{"hash":"%v","contentType":"%s"}]}`, key, contentType)
+	r = strings.NewReader(manifest)
+	key, waitManifest, err := a.Store(cCtx, r, int64(len(manifest)), toEncrypt)
+	if err != nil {
+		return nil, nil, err
+	}
+	tag.DoneSplit(key)
+	return key, func(ctx context.Context) error {
+		err := waitContent(ctx)
+		if err != nil {
+			return err
+		}
+		return waitManifest(ctx)
+	}, nil
+}
--- a/api/client/client.go
+++ b/api/client/client.go
@ -0,0 +1,829 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package client
+
+import (
+	"archive/tar"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptrace"
+	"net/textproto"
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/api"
+	swarmhttp "github.com/ethersphere/swarm/api/http"
+	"github.com/ethersphere/swarm/spancontext"
+	"github.com/ethersphere/swarm/storage/feed"
+	"github.com/pborman/uuid"
+)
+
+var (
+	ErrUnauthorized = errors.New("unauthorized")
+)
+
+func NewClient(gateway string) *Client {
+	return &Client{
+		Gateway: gateway,
+	}
+}
+
+// Client wraps interaction with a swarm HTTP gateway.
+type Client struct {
+	Gateway string
+}
+
+// UploadRaw uploads raw data to swarm and returns the resulting hash. If toEncrypt is true it
+// uploads encrypted data
+func (c *Client) UploadRaw(r io.Reader, size int64, toEncrypt bool) (string, error) {
+	if size <= 0 {
+		return "", errors.New("data size must be greater than zero")
+	}
+	addr := ""
+	if toEncrypt {
+		addr = "encrypt"
+	}
+	req, err := http.NewRequest("POST", c.Gateway+"/bzz-raw:/"+addr, r)
+	if err != nil {
+		return "", err
+	}
+	req.ContentLength = size
+	req.Header.Set(swarmhttp.SwarmTagHeaderName, fmt.Sprintf("raw_upload_%d", time.Now().Unix()))
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	data, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// DownloadRaw downloads raw data from swarm and it returns a ReadCloser and a bool whether the
+// content was encrypted
+func (c *Client) DownloadRaw(hash string) (io.ReadCloser, bool, error) {
+	uri := c.Gateway + "/bzz-raw:/" + hash
+	res, err := http.DefaultClient.Get(uri)
+	if err != nil {
+		return nil, false, err
+	}
+	if res.StatusCode != http.StatusOK {
+		res.Body.Close()
+		return nil, false, fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	isEncrypted := (res.Header.Get("X-Decrypted") == "true")
+	return res.Body, isEncrypted, nil
+}
+
+// File represents a file in a swarm manifest and is used for uploading and
+// downloading content to and from swarm
+type File struct {
+	io.ReadCloser
+	api.ManifestEntry
+	Tag string
+}
+
+// Open opens a local file which can then be passed to client.Upload to upload
+// it to swarm
+func Open(path string) (*File, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	stat, err := f.Stat()
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+
+	contentType, err := api.DetectContentType(f.Name(), f)
+	if err != nil {
+		return nil, err
+	}
+
+	return &File{
+		ReadCloser: f,
+		ManifestEntry: api.ManifestEntry{
+			ContentType: contentType,
+			Mode:        int64(stat.Mode()),
+			Size:        stat.Size(),
+			ModTime:     stat.ModTime(),
+		},
+		Tag: filepath.Base(path),
+	}, nil
+}
+
+// Upload uploads a file to swarm and either adds it to an existing manifest
+// (if the manifest argument is non-empty) or creates a new manifest containing
+// the file, returning the resulting manifest hash (the file will then be
+// available at bzz:/<hash>/<path>)
+func (c *Client) Upload(file *File, manifest string, toEncrypt bool) (string, error) {
+	if file.Size <= 0 {
+		return "", errors.New("file size must be greater than zero")
+	}
+	return c.TarUpload(manifest, &FileUploader{file}, "", toEncrypt)
+}
+
+// Download downloads a file with the given path from the swarm manifest with
+// the given hash (i.e. it gets bzz:/<hash>/<path>)
+func (c *Client) Download(hash, path string) (*File, error) {
+	uri := c.Gateway + "/bzz:/" + hash + "/" + path
+	res, err := http.DefaultClient.Get(uri)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		res.Body.Close()
+		return nil, fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	return &File{
+		ReadCloser: res.Body,
+		ManifestEntry: api.ManifestEntry{
+			ContentType: res.Header.Get("Content-Type"),
+			Size:        res.ContentLength,
+		},
+	}, nil
+}
+
+// UploadDirectory uploads a directory tree to swarm and either adds the files
+// to an existing manifest (if the manifest argument is non-empty) or creates a
+// new manifest, returning the resulting manifest hash (files from the
+// directory will then be available at bzz:/<hash>/path/to/file), with
+// the file specified in defaultPath being uploaded to the root of the manifest
+// (i.e. bzz:/<hash>/)
+func (c *Client) UploadDirectory(dir, defaultPath, manifest string, toEncrypt bool) (string, error) {
+	stat, err := os.Stat(dir)
+	if err != nil {
+		return "", err
+	} else if !stat.IsDir() {
+		return "", fmt.Errorf("not a directory: %s", dir)
+	}
+	if defaultPath != "" {
+		if _, err := os.Stat(filepath.Join(dir, defaultPath)); err != nil {
+			if os.IsNotExist(err) {
+				return "", fmt.Errorf("the default path %q was not found in the upload directory %q", defaultPath, dir)
+			}
+			return "", fmt.Errorf("default path: %v", err)
+		}
+	}
+	return c.TarUpload(manifest, &DirectoryUploader{dir}, defaultPath, toEncrypt)
+}
+
+// DownloadDirectory downloads the files contained in a swarm manifest under
+// the given path into a local directory (existing files will be overwritten)
+func (c *Client) DownloadDirectory(hash, path, destDir, credentials string) error {
+	stat, err := os.Stat(destDir)
+	if err != nil {
+		return err
+	} else if !stat.IsDir() {
+		return fmt.Errorf("not a directory: %s", destDir)
+	}
+
+	uri := c.Gateway + "/bzz:/" + hash + "/" + path
+	req, err := http.NewRequest("GET", uri, nil)
+	if err != nil {
+		return err
+	}
+	if credentials != "" {
+		req.SetBasicAuth("", credentials)
+	}
+	req.Header.Set("Accept", "application/x-tar")
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+	switch res.StatusCode {
+	case http.StatusOK:
+	case http.StatusUnauthorized:
+		return ErrUnauthorized
+	default:
+		return fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	tr := tar.NewReader(res.Body)
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			return nil
+		} else if err != nil {
+			return err
+		}
+		// ignore the default path file
+		if hdr.Name == "" {
+			continue
+		}
+
+		dstPath := filepath.Join(destDir, filepath.Clean(strings.TrimPrefix(hdr.Name, path)))
+		if err := os.MkdirAll(filepath.Dir(dstPath), 0755); err != nil {
+			return err
+		}
+		var mode os.FileMode = 0644
+		if hdr.Mode > 0 {
+			mode = os.FileMode(hdr.Mode)
+		}
+		dst, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, mode)
+		if err != nil {
+			return err
+		}
+		n, err := io.Copy(dst, tr)
+		dst.Close()
+		if err != nil {
+			return err
+		} else if n != hdr.Size {
+			return fmt.Errorf("expected %s to be %d bytes but got %d", hdr.Name, hdr.Size, n)
+		}
+	}
+}
+
+// DownloadFile downloads a single file into the destination directory
+// if the manifest entry does not specify a file name - it will fallback
+// to the hash of the file as a filename
+func (c *Client) DownloadFile(hash, path, dest, credentials string) error {
+	hasDestinationFilename := false
+	if stat, err := os.Stat(dest); err == nil {
+		hasDestinationFilename = !stat.IsDir()
+	} else {
+		if os.IsNotExist(err) {
+			// does not exist - should be created
+			hasDestinationFilename = true
+		} else {
+			return fmt.Errorf("could not stat path: %v", err)
+		}
+	}
+
+	manifestList, err := c.List(hash, path, credentials)
+	if err != nil {
+		return err
+	}
+
+	switch len(manifestList.Entries) {
+	case 0:
+		return fmt.Errorf("could not find path requested at manifest address. make sure the path you've specified is correct")
+	case 1:
+		//continue
+	default:
+		return fmt.Errorf("got too many matches for this path")
+	}
+
+	uri := c.Gateway + "/bzz:/" + hash + "/" + path
+	req, err := http.NewRequest("GET", uri, nil)
+	if err != nil {
+		return err
+	}
+	if credentials != "" {
+		req.SetBasicAuth("", credentials)
+	}
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+	switch res.StatusCode {
+	case http.StatusOK:
+	case http.StatusUnauthorized:
+		return ErrUnauthorized
+	default:
+		return fmt.Errorf("unexpected HTTP status: expected 200 OK, got %d", res.StatusCode)
+	}
+	filename := ""
+	if hasDestinationFilename {
+		filename = dest
+	} else {
+		// try to assert
+		re := regexp.MustCompile("[^/]+$") //everything after last slash
+
+		if results := re.FindAllString(path, -1); len(results) > 0 {
+			filename = results[len(results)-1]
+		} else {
+			if entry := manifestList.Entries[0]; entry.Path != "" && entry.Path != "/" {
+				filename = entry.Path
+			} else {
+				// assume hash as name if there's nothing from the command line
+				filename = hash
+			}
+		}
+		filename = filepath.Join(dest, filename)
+	}
+	filePath, err := filepath.Abs(filename)
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(filePath), 0777); err != nil {
+		return err
+	}
+
+	dst, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer dst.Close()
+
+	_, err = io.Copy(dst, res.Body)
+	return err
+}
+
+// UploadManifest uploads the given manifest to swarm
+func (c *Client) UploadManifest(m *api.Manifest, toEncrypt bool) (string, error) {
+	data, err := json.Marshal(m)
+	if err != nil {
+		return "", err
+	}
+	return c.UploadRaw(bytes.NewReader(data), int64(len(data)), toEncrypt)
+}
+
+// DownloadManifest downloads a swarm manifest
+func (c *Client) DownloadManifest(hash string) (*api.Manifest, bool, error) {
+	res, isEncrypted, err := c.DownloadRaw(hash)
+	if err != nil {
+		return nil, isEncrypted, err
+	}
+	defer res.Close()
+	var manifest api.Manifest
+	if err := json.NewDecoder(res).Decode(&manifest); err != nil {
+		return nil, isEncrypted, err
+	}
+	return &manifest, isEncrypted, nil
+}
+
+// List list files in a swarm manifest which have the given prefix, grouping
+// common prefixes using "/" as a delimiter.
+//
+// For example, if the manifest represents the following directory structure:
+//
+// file1.txt
+// file2.txt
+// dir1/file3.txt
+// dir1/dir2/file4.txt
+//
+// Then:
+//
+// - a prefix of ""      would return [dir1/, file1.txt, file2.txt]
+// - a prefix of "file"  would return [file1.txt, file2.txt]
+// - a prefix of "dir1/" would return [dir1/dir2/, dir1/file3.txt]
+//
+// where entries ending with "/" are common prefixes.
+func (c *Client) List(hash, prefix, credentials string) (*api.ManifestList, error) {
+	req, err := http.NewRequest(http.MethodGet, c.Gateway+"/bzz-list:/"+hash+"/"+prefix, nil)
+	if err != nil {
+		return nil, err
+	}
+	if credentials != "" {
+		req.SetBasicAuth("", credentials)
+	}
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	switch res.StatusCode {
+	case http.StatusOK:
+	case http.StatusUnauthorized:
+		return nil, ErrUnauthorized
+	default:
+		return nil, fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	var list api.ManifestList
+	if err := json.NewDecoder(res.Body).Decode(&list); err != nil {
+		return nil, err
+	}
+	return &list, nil
+}
+
+// Uploader uploads files to swarm using a provided UploadFn
+type Uploader interface {
+	Upload(UploadFn) error
+	Tag() string
+}
+
+type UploaderFunc func(UploadFn) error
+
+func (u UploaderFunc) Upload(upload UploadFn) error {
+	return u(upload)
+}
+
+func (u UploaderFunc) Tag() string {
+	return fmt.Sprintf("multipart_upload_%d", time.Now().Unix())
+}
+
+// DirectoryUploader implements Uploader
+var _ Uploader = &DirectoryUploader{}
+
+// DirectoryUploader uploads all files in a directory, optionally uploading
+// a file to the default path
+type DirectoryUploader struct {
+	Dir string
+}
+
+func (d *DirectoryUploader) Tag() string {
+	return filepath.Base(d.Dir)
+}
+
+// Upload performs the upload of the directory and default path
+func (d *DirectoryUploader) Upload(upload UploadFn) error {
+	return filepath.Walk(d.Dir, func(path string, f os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if f.IsDir() {
+			return nil
+		}
+		file, err := Open(path)
+		if err != nil {
+			return err
+		}
+		relPath, err := filepath.Rel(d.Dir, path)
+		if err != nil {
+			return err
+		}
+		file.Path = filepath.ToSlash(relPath)
+		return upload(file)
+	})
+}
+
+var _ Uploader = &FileUploader{}
+
+// FileUploader uploads a single file
+type FileUploader struct {
+	File *File
+}
+
+func (f *FileUploader) Tag() string {
+	return f.File.Tag
+}
+
+// Upload performs the upload of the file
+func (f *FileUploader) Upload(upload UploadFn) error {
+	return upload(f.File)
+}
+
+// UploadFn is the type of function passed to an Uploader to perform the upload
+// of a single file (for example, a directory uploader would call a provided
+// UploadFn for each file in the directory tree)
+type UploadFn func(file *File) error
+
+// TarUpload uses the given Uploader to upload files to swarm as a tar stream,
+// returning the resulting manifest hash
+func (c *Client) TarUpload(hash string, uploader Uploader, defaultPath string, toEncrypt bool) (string, error) {
+	ctx, sp := spancontext.StartSpan(context.Background(), "api.client.tarupload")
+	defer sp.Finish()
+
+	var tn time.Time
+
+	reqR, reqW := io.Pipe()
+	defer reqR.Close()
+	addr := hash
+
+	// If there is a hash already (a manifest), then that manifest will determine if the upload has
+	// to be encrypted or not. If there is no manifest then the toEncrypt parameter decides if
+	// there is encryption or not.
+	if hash == "" && toEncrypt {
+		// This is the built-in address for the encrypted upload endpoint
+		addr = "encrypt"
+	}
+	req, err := http.NewRequest("POST", c.Gateway+"/bzz:/"+addr, reqR)
+	if err != nil {
+		return "", err
+	}
+
+	trace := GetClientTrace("swarm api client - upload tar", "api.client.uploadtar", uuid.New()[:8], &tn)
+
+	req = req.WithContext(httptrace.WithClientTrace(ctx, trace))
+	transport := http.DefaultTransport
+
+	req.Header.Set("Content-Type", "application/x-tar")
+	if defaultPath != "" {
+		q := req.URL.Query()
+		q.Set("defaultpath", defaultPath)
+		req.URL.RawQuery = q.Encode()
+	}
+
+	tag := uploader.Tag()
+	if tag == "" {
+		tag = "unnamed_tag_" + fmt.Sprintf("%d", time.Now().Unix())
+	}
+	log.Trace("setting upload tag", "tag", tag)
+
+	req.Header.Set(swarmhttp.SwarmTagHeaderName, tag)
+
+	// use 'Expect: 100-continue' so we don't send the request body if
+	// the server refuses the request
+	req.Header.Set("Expect", "100-continue")
+
+	tw := tar.NewWriter(reqW)
+
+	// define an UploadFn which adds files to the tar stream
+	uploadFn := func(file *File) error {
+		hdr := &tar.Header{
+			Name:    file.Path,
+			Mode:    file.Mode,
+			Size:    file.Size,
+			ModTime: file.ModTime,
+			Xattrs: map[string]string{
+				"user.swarm.content-type": file.ContentType,
+			},
+		}
+		if err := tw.WriteHeader(hdr); err != nil {
+			return err
+		}
+		_, err = io.Copy(tw, file)
+		return err
+	}
+
+	// run the upload in a goroutine so we can send the request headers and
+	// wait for a '100 Continue' response before sending the tar stream
+	go func() {
+		err := uploader.Upload(uploadFn)
+		if err == nil {
+			err = tw.Close()
+		}
+		reqW.CloseWithError(err)
+	}()
+	tn = time.Now()
+	res, err := transport.RoundTrip(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	data, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// MultipartUpload uses the given Uploader to upload files to swarm as a
+// multipart form, returning the resulting manifest hash
+func (c *Client) MultipartUpload(hash string, uploader Uploader) (string, error) {
+	reqR, reqW := io.Pipe()
+	defer reqR.Close()
+	req, err := http.NewRequest("POST", c.Gateway+"/bzz:/"+hash, reqR)
+	if err != nil {
+		return "", err
+	}
+
+	// use 'Expect: 100-continue' so we don't send the request body if
+	// the server refuses the request
+	req.Header.Set("Expect", "100-continue")
+
+	mw := multipart.NewWriter(reqW)
+	req.Header.Set("Content-Type", fmt.Sprintf("multipart/form-data; boundary=%q", mw.Boundary()))
+	req.Header.Set(swarmhttp.SwarmTagHeaderName, fmt.Sprintf("multipart_upload_%d", time.Now().Unix()))
+
+	// define an UploadFn which adds files to the multipart form
+	uploadFn := func(file *File) error {
+		hdr := make(textproto.MIMEHeader)
+		hdr.Set("Content-Disposition", fmt.Sprintf("form-data; name=%q", file.Path))
+		hdr.Set("Content-Type", file.ContentType)
+		hdr.Set("Content-Length", strconv.FormatInt(file.Size, 10))
+		w, err := mw.CreatePart(hdr)
+		if err != nil {
+			return err
+		}
+		_, err = io.Copy(w, file)
+		return err
+	}
+
+	// run the upload in a goroutine so we can send the request headers and
+	// wait for a '100 Continue' response before sending the multipart form
+	go func() {
+		err := uploader.Upload(uploadFn)
+		if err == nil {
+			err = mw.Close()
+		}
+		reqW.CloseWithError(err)
+	}()
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected HTTP status: %s", res.Status)
+	}
+	data, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+// ErrNoFeedUpdatesFound is returned when Swarm cannot find updates of the given feed
+var ErrNoFeedUpdatesFound = errors.New("No updates found for this feed")
+
+// CreateFeedWithManifest creates a feed manifest, initializing it with the provided
+// data
+// Returns the resulting feed manifest address that you can use to include in an ENS Resolver (setContent)
+// or reference future updates (Client.UpdateFeed)
+func (c *Client) CreateFeedWithManifest(request *feed.Request) (string, error) {
+	responseStream, err := c.updateFeed(request, true)
+	if err != nil {
+		return "", err
+	}
+	defer responseStream.Close()
+
+	body, err := ioutil.ReadAll(responseStream)
+	if err != nil {
+		return "", err
+	}
+
+	var manifestAddress string
+	if err = json.Unmarshal(body, &manifestAddress); err != nil {
+		return "", err
+	}
+	return manifestAddress, nil
+}
+
+// UpdateFeed allows you to set a new version of your content
+func (c *Client) UpdateFeed(request *feed.Request) error {
+	_, err := c.updateFeed(request, false)
+	return err
+}
+
+func (c *Client) updateFeed(request *feed.Request, createManifest bool) (io.ReadCloser, error) {
+	URL, err := url.Parse(c.Gateway)
+	if err != nil {
+		return nil, err
+	}
+	URL.Path = "/bzz-feed:/"
+	values := URL.Query()
+	body := request.AppendValues(values)
+	if createManifest {
+		values.Set("manifest", "1")
+	}
+	URL.RawQuery = values.Encode()
+
+	req, err := http.NewRequest("POST", URL.String(), bytes.NewBuffer(body))
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Body, nil
+}
+
+// QueryFeed returns a byte stream with the raw content of the feed update
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
+// points to that address
+func (c *Client) QueryFeed(query *feed.Query, manifestAddressOrDomain string) (io.ReadCloser, error) {
+	return c.queryFeed(query, manifestAddressOrDomain, false)
+}
+
+// queryFeed returns a byte stream with the raw content of the feed update
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
+// points to that address
+// meta set to true will instruct the node return feed metainformation instead
+func (c *Client) queryFeed(query *feed.Query, manifestAddressOrDomain string, meta bool) (io.ReadCloser, error) {
+	URL, err := url.Parse(c.Gateway)
+	if err != nil {
+		return nil, err
+	}
+	URL.Path = "/bzz-feed:/" + manifestAddressOrDomain
+	values := URL.Query()
+	if query != nil {
+		query.AppendValues(values) //adds query parameters
+	}
+	if meta {
+		values.Set("meta", "1")
+	}
+	URL.RawQuery = values.Encode()
+	res, err := http.Get(URL.String())
+	if err != nil {
+		return nil, err
+	}
+
+	if res.StatusCode != http.StatusOK {
+		if res.StatusCode == http.StatusNotFound {
+			return nil, ErrNoFeedUpdatesFound
+		}
+		errorMessageBytes, err := ioutil.ReadAll(res.Body)
+		var errorMessage string
+		if err != nil {
+			errorMessage = "cannot retrieve error message: " + err.Error()
+		} else {
+			errorMessage = string(errorMessageBytes)
+		}
+		return nil, fmt.Errorf("Error retrieving feed updates: %s", errorMessage)
+	}
+
+	return res.Body, nil
+}
+
+// GetFeedRequest returns a structure that describes the referenced feed status
+// manifestAddressOrDomain is the address you obtained in CreateFeedWithManifest or an ENS domain whose Resolver
+// points to that address
+func (c *Client) GetFeedRequest(query *feed.Query, manifestAddressOrDomain string) (*feed.Request, error) {
+
+	responseStream, err := c.queryFeed(query, manifestAddressOrDomain, true)
+	if err != nil {
+		return nil, err
+	}
+	defer responseStream.Close()
+
+	body, err := ioutil.ReadAll(responseStream)
+	if err != nil {
+		return nil, err
+	}
+
+	var metadata feed.Request
+	if err := metadata.UnmarshalJSON(body); err != nil {
+		return nil, err
+	}
+	return &metadata, nil
+}
+
+func GetClientTrace(traceMsg, metricPrefix, ruid string, tn *time.Time) *httptrace.ClientTrace {
+	trace := &httptrace.ClientTrace{
+		GetConn: func(_ string) {
+			log.Trace(traceMsg+" - http get", "event", "GetConn", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".getconn", nil).Update(time.Since(*tn))
+		},
+		GotConn: func(_ httptrace.GotConnInfo) {
+			log.Trace(traceMsg+" - http get", "event", "GotConn", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".gotconn", nil).Update(time.Since(*tn))
+		},
+		PutIdleConn: func(err error) {
+			log.Trace(traceMsg+" - http get", "event", "PutIdleConn", "ruid", ruid, "err", err)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".putidle", nil).Update(time.Since(*tn))
+		},
+		GotFirstResponseByte: func() {
+			log.Trace(traceMsg+" - http get", "event", "GotFirstResponseByte", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".firstbyte", nil).Update(time.Since(*tn))
+		},
+		Got100Continue: func() {
+			log.Trace(traceMsg, "event", "Got100Continue", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".got100continue", nil).Update(time.Since(*tn))
+		},
+		DNSStart: func(_ httptrace.DNSStartInfo) {
+			log.Trace(traceMsg, "event", "DNSStart", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".dnsstart", nil).Update(time.Since(*tn))
+		},
+		DNSDone: func(_ httptrace.DNSDoneInfo) {
+			log.Trace(traceMsg, "event", "DNSDone", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".dnsdone", nil).Update(time.Since(*tn))
+		},
+		ConnectStart: func(network, addr string) {
+			log.Trace(traceMsg, "event", "ConnectStart", "ruid", ruid, "network", network, "addr", addr)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".connectstart", nil).Update(time.Since(*tn))
+		},
+		ConnectDone: func(network, addr string, err error) {
+			log.Trace(traceMsg, "event", "ConnectDone", "ruid", ruid, "network", network, "addr", addr, "err", err)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".connectdone", nil).Update(time.Since(*tn))
+		},
+		WroteHeaders: func() {
+			log.Trace(traceMsg, "event", "WroteHeaders(request)", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".wroteheaders", nil).Update(time.Since(*tn))
+		},
+		Wait100Continue: func() {
+			log.Trace(traceMsg, "event", "Wait100Continue", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".wait100continue", nil).Update(time.Since(*tn))
+		},
+		WroteRequest: func(_ httptrace.WroteRequestInfo) {
+			log.Trace(traceMsg, "event", "WroteRequest", "ruid", ruid)
+			metrics.GetOrRegisterResettingTimer(metricPrefix+".wroterequest", nil).Update(time.Since(*tn))
+		},
+	}
+	return trace
+}
--- a/api/client/client_test.go
+++ b/api/client/client_test.go
@ -0,0 +1,608 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package client
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethersphere/swarm/api"
+	swarmhttp "github.com/ethersphere/swarm/api/http"
+	"github.com/ethersphere/swarm/storage"
+	"github.com/ethersphere/swarm/storage/feed"
+	"github.com/ethersphere/swarm/storage/feed/lookup"
+	"github.com/ethersphere/swarm/testutil"
+)
+
+func serverFunc(api *api.API) swarmhttp.TestServer {
+	return swarmhttp.NewServer(api, "")
+}
+
+// TestClientUploadDownloadRaw test uploading and downloading raw data to swarm
+func TestClientUploadDownloadRaw(t *testing.T) {
+	testClientUploadDownloadRaw(false, t)
+}
+
+func TestClientUploadDownloadRawEncrypted(t *testing.T) {
+	if testutil.RaceEnabled {
+		t.Skip("flaky with -race on Travis")
+		// See: https://github.com/ethersphere/go-ethereum/issues/1254
+	}
+
+	testClientUploadDownloadRaw(true, t)
+}
+
+func testClientUploadDownloadRaw(toEncrypt bool, t *testing.T) {
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	client := NewClient(srv.URL)
+
+	// upload some raw data
+	data := []byte("foo123")
+	hash, err := client.UploadRaw(bytes.NewReader(data), int64(len(data)), toEncrypt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// check the tag was created successfully
+	tag := srv.Tags.All()[0]
+	testutil.CheckTag(t, tag, 1, 1, 0, 1)
+
+	// check we can download the same data
+	res, isEncrypted, err := client.DownloadRaw(hash)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if isEncrypted != toEncrypt {
+		t.Fatalf("Expected encyption status %v got %v", toEncrypt, isEncrypted)
+	}
+	defer res.Close()
+	gotData, err := ioutil.ReadAll(res)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(gotData, data) {
+		t.Fatalf("expected downloaded data to be %q, got %q", data, gotData)
+	}
+}
+
+// TestClientUploadDownloadFiles test uploading and downloading files to swarm
+// manifests
+func TestClientUploadDownloadFiles(t *testing.T) {
+	testClientUploadDownloadFiles(false, t)
+}
+
+func TestClientUploadDownloadFilesEncrypted(t *testing.T) {
+	testClientUploadDownloadFiles(true, t)
+}
+
+func testClientUploadDownloadFiles(toEncrypt bool, t *testing.T) {
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	client := NewClient(srv.URL)
+	upload := func(manifest, path string, data []byte) string {
+		file := &File{
+			ReadCloser: ioutil.NopCloser(bytes.NewReader(data)),
+			ManifestEntry: api.ManifestEntry{
+				Path:        path,
+				ContentType: "text/plain",
+				Size:        int64(len(data)),
+			},
+		}
+		hash, err := client.Upload(file, manifest, toEncrypt)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return hash
+	}
+	checkDownload := func(manifest, path string, expected []byte) {
+		file, err := client.Download(manifest, path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if file.Size != int64(len(expected)) {
+			t.Fatalf("expected downloaded file to be %d bytes, got %d", len(expected), file.Size)
+		}
+		if file.ContentType != "text/plain" {
+			t.Fatalf("expected downloaded file to have type %q, got %q", "text/plain", file.ContentType)
+		}
+		data, err := ioutil.ReadAll(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(data, expected) {
+			t.Fatalf("expected downloaded data to be %q, got %q", expected, data)
+		}
+	}
+
+	// upload a file to the root of a manifest
+	rootData := []byte("some-data")
+	rootHash := upload("", "", rootData)
+
+	// check we can download the root file
+	checkDownload(rootHash, "", rootData)
+
+	// upload another file to the same manifest
+	otherData := []byte("some-other-data")
+	newHash := upload(rootHash, "some/other/path", otherData)
+
+	// check we can download both files from the new manifest
+	checkDownload(newHash, "", rootData)
+	checkDownload(newHash, "some/other/path", otherData)
+
+	// replace the root file with different data
+	newHash = upload(newHash, "", otherData)
+
+	// check both files have the other data
+	checkDownload(newHash, "", otherData)
+	checkDownload(newHash, "some/other/path", otherData)
+}
+
+var testDirFiles = []string{
+	"file1.txt",
+	"file2.txt",
+	"dir1/file3.txt",
+	"dir1/file4.txt",
+	"dir2/file5.txt",
+	"dir2/dir3/file6.txt",
+	"dir2/dir4/file7.txt",
+	"dir2/dir4/file8.txt",
+}
+
+func newTestDirectory(t *testing.T) string {
+	dir, err := ioutil.TempDir("", "swarm-client-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, file := range testDirFiles {
+		path := filepath.Join(dir, file)
+		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+			os.RemoveAll(dir)
+			t.Fatalf("error creating dir for %s: %s", path, err)
+		}
+		if err := ioutil.WriteFile(path, []byte(file), 0644); err != nil {
+			os.RemoveAll(dir)
+			t.Fatalf("error writing file %s: %s", path, err)
+		}
+	}
+
+	return dir
+}
+
+// TestClientUploadDownloadDirectory tests uploading and downloading a
+// directory of files to a swarm manifest
+func TestClientUploadDownloadDirectory(t *testing.T) {
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	dir := newTestDirectory(t)
+	defer os.RemoveAll(dir)
+
+	// upload the directory
+	client := NewClient(srv.URL)
+	defaultPath := testDirFiles[0]
+	hash, err := client.UploadDirectory(dir, defaultPath, "", false)
+	if err != nil {
+		t.Fatalf("error uploading directory: %s", err)
+	}
+
+	// check the tag was created successfully
+	tag := srv.Tags.All()[0]
+	testutil.CheckTag(t, tag, 9, 9, 0, 9)
+
+	// check we can download the individual files
+	checkDownloadFile := func(path string, expected []byte) {
+		file, err := client.Download(hash, path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		data, err := ioutil.ReadAll(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(data, expected) {
+			t.Fatalf("expected data to be %q, got %q", expected, data)
+		}
+	}
+	for _, file := range testDirFiles {
+		checkDownloadFile(file, []byte(file))
+	}
+
+	// check we can download the default path
+	checkDownloadFile("", []byte(testDirFiles[0]))
+
+	// check we can download the directory
+	tmp, err := ioutil.TempDir("", "swarm-client-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmp)
+	if err := client.DownloadDirectory(hash, "", tmp, ""); err != nil {
+		t.Fatal(err)
+	}
+	for _, file := range testDirFiles {
+		data, err := ioutil.ReadFile(filepath.Join(tmp, file))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(data, []byte(file)) {
+			t.Fatalf("expected data to be %q, got %q", file, data)
+		}
+	}
+}
+
+// TestClientFileList tests listing files in a swarm manifest
+func TestClientFileList(t *testing.T) {
+	testClientFileList(false, t)
+}
+
+func TestClientFileListEncrypted(t *testing.T) {
+	testClientFileList(true, t)
+}
+
+func testClientFileList(toEncrypt bool, t *testing.T) {
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	dir := newTestDirectory(t)
+	defer os.RemoveAll(dir)
+
+	client := NewClient(srv.URL)
+	hash, err := client.UploadDirectory(dir, "", "", toEncrypt)
+	if err != nil {
+		t.Fatalf("error uploading directory: %s", err)
+	}
+
+	ls := func(prefix string) []string {
+		list, err := client.List(hash, prefix, "")
+		if err != nil {
+			t.Fatal(err)
+		}
+		paths := make([]string, 0, len(list.CommonPrefixes)+len(list.Entries))
+		paths = append(paths, list.CommonPrefixes...)
+		for _, entry := range list.Entries {
+			paths = append(paths, entry.Path)
+		}
+		sort.Strings(paths)
+		return paths
+	}
+
+	tests := map[string][]string{
+		"":                    {"dir1/", "dir2/", "file1.txt", "file2.txt"},
+		"file":                {"file1.txt", "file2.txt"},
+		"file1":               {"file1.txt"},
+		"file2.txt":           {"file2.txt"},
+		"file12":              {},
+		"dir":                 {"dir1/", "dir2/"},
+		"dir1":                {"dir1/"},
+		"dir1/":               {"dir1/file3.txt", "dir1/file4.txt"},
+		"dir1/file":           {"dir1/file3.txt", "dir1/file4.txt"},
+		"dir1/file3.txt":      {"dir1/file3.txt"},
+		"dir1/file34":         {},
+		"dir2/":               {"dir2/dir3/", "dir2/dir4/", "dir2/file5.txt"},
+		"dir2/file":           {"dir2/file5.txt"},
+		"dir2/dir":            {"dir2/dir3/", "dir2/dir4/"},
+		"dir2/dir3/":          {"dir2/dir3/file6.txt"},
+		"dir2/dir4/":          {"dir2/dir4/file7.txt", "dir2/dir4/file8.txt"},
+		"dir2/dir4/file":      {"dir2/dir4/file7.txt", "dir2/dir4/file8.txt"},
+		"dir2/dir4/file7.txt": {"dir2/dir4/file7.txt"},
+		"dir2/dir4/file78":    {},
+	}
+	for prefix, expected := range tests {
+		actual := ls(prefix)
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("expected prefix %q to return %v, got %v", prefix, expected, actual)
+		}
+	}
+}
+
+// TestClientMultipartUpload tests uploading files to swarm using a multipart
+// upload
+func TestClientMultipartUpload(t *testing.T) {
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	// define an uploader which uploads testDirFiles with some data
+	// note: this test should result in SEEN chunks. assert accordingly
+	data := []byte("some-data")
+	uploader := UploaderFunc(func(upload UploadFn) error {
+		for _, name := range testDirFiles {
+			file := &File{
+				ReadCloser: ioutil.NopCloser(bytes.NewReader(data)),
+				ManifestEntry: api.ManifestEntry{
+					Path:        name,
+					ContentType: "text/plain",
+					Size:        int64(len(data)),
+				},
+			}
+			if err := upload(file); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+
+	// upload the files as a multipart upload
+	client := NewClient(srv.URL)
+	hash, err := client.MultipartUpload("", uploader)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// check the tag was created successfully
+	tag := srv.Tags.All()[0]
+	testutil.CheckTag(t, tag, 9, 9, 7, 9)
+
+	// check we can download the individual files
+	checkDownloadFile := func(path string) {
+		file, err := client.Download(hash, path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		gotData, err := ioutil.ReadAll(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !bytes.Equal(gotData, data) {
+			t.Fatalf("expected data to be %q, got %q", data, gotData)
+		}
+	}
+	for _, file := range testDirFiles {
+		checkDownloadFile(file)
+	}
+}
+
+func newTestSigner() (*feed.GenericSigner, error) {
+	privKey, err := crypto.HexToECDSA("deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")
+	if err != nil {
+		return nil, err
+	}
+	return feed.NewGenericSigner(privKey), nil
+}
+
+// Test the transparent resolving of feed updates with bzz:// scheme
+//
+// First upload data to bzz:, and store the Swarm hash to the resulting manifest in a feed update.
+// This effectively uses a feed to store a pointer to content rather than the content itself
+// Retrieving the update with the Swarm hash should return the manifest pointing directly to the data
+// and raw retrieve of that hash should return the data
+func TestClientBzzWithFeed(t *testing.T) {
+
+	signer, _ := newTestSigner()
+
+	// Initialize a Swarm test server
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	swarmClient := NewClient(srv.URL)
+	defer srv.Close()
+
+	// put together some data for our test:
+	dataBytes := []byte(`
+	//
+	// Create some data our manifest will point to. Data that could be very big and wouldn't fit in a feed update.
+	// So what we are going to do is upload it to Swarm bzz:// and obtain a **manifest hash** pointing to it:
+	//
+	// MANIFEST HASH --> DATA
+	//
+	// Then, we store that **manifest hash** into a Swarm Feed update. Once we have done this,
+	// we can use the **feed manifest hash** in bzz:// instead, this way: bzz://feed-manifest-hash.
+	//
+	// FEED MANIFEST HASH --> MANIFEST HASH --> DATA
+	//
+	// Given that we can update the feed at any time with a new **manifest hash** but the **feed manifest hash**
+	// stays constant, we have effectively created a fixed address to changing content. (Applause)
+	//
+	// FEED MANIFEST HASH (the same) --> MANIFEST HASH(2) --> DATA(2)
+	//
+	`)
+
+	// Create a virtual File out of memory containing the above data
+	f := &File{
+		ReadCloser: ioutil.NopCloser(bytes.NewReader(dataBytes)),
+		ManifestEntry: api.ManifestEntry{
+			ContentType: "text/plain",
+			Mode:        0660,
+			Size:        int64(len(dataBytes)),
+		},
+	}
+
+	// upload data to bzz:// and retrieve the content-addressed manifest hash, hex-encoded.
+	manifestAddressHex, err := swarmClient.Upload(f, "", false)
+	if err != nil {
+		t.Fatalf("Error creating manifest: %s", err)
+	}
+
+	// convert the hex-encoded manifest hash to a 32-byte slice
+	manifestAddress := common.FromHex(manifestAddressHex)
+
+	if len(manifestAddress) != storage.AddressLength {
+		t.Fatalf("Something went wrong. Got a hash of an unexpected length. Expected %d bytes. Got %d", storage.AddressLength, len(manifestAddress))
+	}
+
+	// Now create a **feed manifest**. For that, we need a topic:
+	topic, _ := feed.NewTopic("interesting topic indeed", nil)
+
+	// Build a feed request to update data
+	request := feed.NewFirstRequest(topic)
+
+	// Put the 32-byte address of the manifest into the feed update
+	request.SetData(manifestAddress)
+
+	// Sign the update
+	if err := request.Sign(signer); err != nil {
+		t.Fatalf("Error signing update: %s", err)
+	}
+
+	// Publish the update and at the same time request a **feed manifest** to be created
+	feedManifestAddressHex, err := swarmClient.CreateFeedWithManifest(request)
+	if err != nil {
+		t.Fatalf("Error creating feed manifest: %s", err)
+	}
+
+	// Check we have received the exact **feed manifest** to be expected
+	// given the topic and user signing the updates:
+	correctFeedManifestAddrHex := "747c402e5b9dc715a25a4393147512167bab018a007fad7cdcd9adc7fce1ced2"
+	if feedManifestAddressHex != correctFeedManifestAddrHex {
+		t.Fatalf("Response feed manifest mismatch, expected '%s', got '%s'", correctFeedManifestAddrHex, feedManifestAddressHex)
+	}
+
+	// Check we get a not found error when trying to get feed updates with a made-up manifest
+	_, err = swarmClient.QueryFeed(nil, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
+	if err != ErrNoFeedUpdatesFound {
+		t.Fatalf("Expected to receive ErrNoFeedUpdatesFound error. Got: %s", err)
+	}
+
+	// If we query the feed directly we should get **manifest hash** back:
+	reader, err := swarmClient.QueryFeed(nil, correctFeedManifestAddrHex)
+	if err != nil {
+		t.Fatalf("Error retrieving feed updates: %s", err)
+	}
+	defer reader.Close()
+	gotData, err := ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	//Check that indeed the **manifest hash** is retrieved
+	if !bytes.Equal(manifestAddress, gotData) {
+		t.Fatalf("Expected: %v, got %v", manifestAddress, gotData)
+	}
+
+	// Now the final test we were looking for: Use bzz://<feed-manifest> and that should resolve all manifests
+	// and return the original data directly:
+	f, err = swarmClient.Download(feedManifestAddressHex, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	gotData, err = ioutil.ReadAll(f)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check that we get back the original data:
+	if !bytes.Equal(dataBytes, gotData) {
+		t.Fatalf("Expected: %v, got %v", manifestAddress, gotData)
+	}
+}
+
+// TestClientCreateUpdateFeed will check that feeds can be created and updated via the HTTP client.
+func TestClientCreateUpdateFeed(t *testing.T) {
+
+	signer, _ := newTestSigner()
+
+	srv := swarmhttp.NewTestSwarmServer(t, serverFunc, nil)
+	client := NewClient(srv.URL)
+	defer srv.Close()
+
+	// set raw data for the feed update
+	databytes := []byte("En un lugar de La Mancha, de cuyo nombre no quiero acordarme...")
+
+	// our feed topic name
+	topic, _ := feed.NewTopic("El Quijote", nil)
+	createRequest := feed.NewFirstRequest(topic)
+
+	createRequest.SetData(databytes)
+	if err := createRequest.Sign(signer); err != nil {
+		t.Fatalf("Error signing update: %s", err)
+	}
+
+	feedManifestHash, err := client.CreateFeedWithManifest(createRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	correctManifestAddrHex := "0e9b645ebc3da167b1d56399adc3276f7a08229301b72a03336be0e7d4b71882"
+	if feedManifestHash != correctManifestAddrHex {
+		t.Fatalf("Response feed manifest mismatch, expected '%s', got '%s'", correctManifestAddrHex, feedManifestHash)
+	}
+
+	reader, err := client.QueryFeed(nil, correctManifestAddrHex)
+	if err != nil {
+		t.Fatalf("Error retrieving feed updates: %s", err)
+	}
+	defer reader.Close()
+	gotData, err := ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(databytes, gotData) {
+		t.Fatalf("Expected: %v, got %v", databytes, gotData)
+	}
+
+	// define different data
+	databytes = []byte("... no ha mucho tiempo que vivía un hidalgo de los de lanza en astillero ...")
+
+	updateRequest, err := client.GetFeedRequest(nil, correctManifestAddrHex)
+	if err != nil {
+		t.Fatalf("Error retrieving update request template: %s", err)
+	}
+
+	updateRequest.SetData(databytes)
+	if err := updateRequest.Sign(signer); err != nil {
+		t.Fatalf("Error signing update: %s", err)
+	}
+
+	if err = client.UpdateFeed(updateRequest); err != nil {
+		t.Fatalf("Error updating feed: %s", err)
+	}
+
+	reader, err = client.QueryFeed(nil, correctManifestAddrHex)
+	if err != nil {
+		t.Fatalf("Error retrieving feed updates: %s", err)
+	}
+	defer reader.Close()
+	gotData, err = ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(databytes, gotData) {
+		t.Fatalf("Expected: %v, got %v", databytes, gotData)
+	}
+
+	// now try retrieving feed updates without a manifest
+
+	fd := &feed.Feed{
+		Topic: topic,
+		User:  signer.Address(),
+	}
+
+	lookupParams := feed.NewQueryLatest(fd, lookup.NoClue)
+	reader, err = client.QueryFeed(lookupParams, "")
+	if err != nil {
+		t.Fatalf("Error retrieving feed updates: %s", err)
+	}
+	defer reader.Close()
+	gotData, err = ioutil.ReadAll(reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.Equal(databytes, gotData) {
+		t.Fatalf("Expected: %v, got %v", databytes, gotData)
+	}
+}
--- a/api/config.go
+++ b/api/config.go
@ -0,0 +1,174 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"crypto/ecdsa"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/node"
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	"github.com/ethersphere/swarm/contracts/ens"
+	"github.com/ethersphere/swarm/network"
+	"github.com/ethersphere/swarm/pss"
+	"github.com/ethersphere/swarm/services/swap"
+	"github.com/ethersphere/swarm/storage"
+)
+
+const (
+	DefaultHTTPListenAddr = "127.0.0.1"
+	DefaultHTTPPort       = "8500"
+)
+
+// separate bzz directories
+// allow several bzz nodes running in parallel
+type Config struct {
+	// serialised/persisted fields
+	*storage.FileStoreParams
+
+	// LocalStore
+	ChunkDbPath   string
+	DbCapacity    uint64
+	CacheCapacity uint
+	BaseKey       []byte
+
+	*network.HiveParams
+	Swap                 *swap.LocalProfile
+	Pss                  *pss.PssParams
+	Contract             common.Address
+	EnsRoot              common.Address
+	EnsAPIs              []string
+	Path                 string
+	ListenAddr           string
+	Port                 string
+	PublicKey            string
+	BzzKey               string
+	Enode                *enode.Node `toml:"-"`
+	NetworkID            uint64
+	SwapEnabled          bool
+	SyncEnabled          bool
+	SyncingSkipCheck     bool
+	DeliverySkipCheck    bool
+	MaxStreamPeerServers int
+	LightNodeEnabled     bool
+	BootnodeMode         bool
+	SyncUpdateDelay      time.Duration
+	SwapAPI              string
+	Cors                 string
+	BzzAccount           string
+	GlobalStoreAPI       string
+	privateKey           *ecdsa.PrivateKey
+}
+
+//create a default config with all parameters to set to defaults
+func NewConfig() (c *Config) {
+
+	c = &Config{
+		FileStoreParams:      storage.NewFileStoreParams(),
+		HiveParams:           network.NewHiveParams(),
+		Swap:                 swap.NewDefaultSwapParams(),
+		Pss:                  pss.NewPssParams(),
+		ListenAddr:           DefaultHTTPListenAddr,
+		Port:                 DefaultHTTPPort,
+		Path:                 node.DefaultDataDir(),
+		EnsAPIs:              nil,
+		EnsRoot:              ens.TestNetAddress,
+		NetworkID:            network.DefaultNetworkID,
+		SwapEnabled:          false,
+		SyncEnabled:          true,
+		SyncingSkipCheck:     false,
+		MaxStreamPeerServers: 10000,
+		DeliverySkipCheck:    true,
+		SyncUpdateDelay:      15 * time.Second,
+		SwapAPI:              "",
+	}
+
+	return
+}
+
+//some config params need to be initialized after the complete
+//config building phase is completed (e.g. due to overriding flags)
+func (c *Config) Init(prvKey *ecdsa.PrivateKey, nodeKey *ecdsa.PrivateKey) error {
+
+	// create swarm dir and record key
+	err := c.createAndSetPath(c.Path, prvKey)
+	if err != nil {
+		return fmt.Errorf("Error creating root swarm data directory: %v", err)
+	}
+	c.setKey(prvKey)
+
+	// create the new enode record
+	// signed with the ephemeral node key
+	enodeParams := &network.EnodeParams{
+		PrivateKey: prvKey,
+		EnodeKey:   nodeKey,
+		Lightnode:  c.LightNodeEnabled,
+		Bootnode:   c.BootnodeMode,
+	}
+	c.Enode, err = network.NewEnode(enodeParams)
+	if err != nil {
+		return fmt.Errorf("Error creating enode: %v", err)
+	}
+
+	// initialize components that depend on the swarm instance's private key
+	if c.SwapEnabled {
+		c.Swap.Init(c.Contract, prvKey)
+	}
+
+	c.privateKey = prvKey
+	c.ChunkDbPath = filepath.Join(c.Path, "chunks")
+	c.BaseKey = common.FromHex(c.BzzKey)
+
+	c.Pss = c.Pss.WithPrivateKey(c.privateKey)
+	return nil
+}
+
+func (c *Config) ShiftPrivateKey() (privKey *ecdsa.PrivateKey) {
+	if c.privateKey != nil {
+		privKey = c.privateKey
+		c.privateKey = nil
+	}
+	return privKey
+}
+
+func (c *Config) setKey(prvKey *ecdsa.PrivateKey) {
+	bzzkeybytes := network.PrivateKeyToBzzKey(prvKey)
+	pubkey := crypto.FromECDSAPub(&prvKey.PublicKey)
+	pubkeyhex := hexutil.Encode(pubkey)
+	keyhex := hexutil.Encode(bzzkeybytes)
+
+	c.privateKey = prvKey
+	c.PublicKey = pubkeyhex
+	c.BzzKey = keyhex
+}
+
+func (c *Config) createAndSetPath(datadirPath string, prvKey *ecdsa.PrivateKey) error {
+	address := crypto.PubkeyToAddress(prvKey.PublicKey)
+	bzzdirPath := filepath.Join(datadirPath, "bzz-"+common.Bytes2Hex(address.Bytes()))
+	err := os.MkdirAll(bzzdirPath, os.ModePerm)
+	if err != nil {
+		return err
+	}
+	c.Path = bzzdirPath
+	return nil
+}
--- a/api/config_test.go
+++ b/api/config_test.go
@ -0,0 +1,66 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+func TestConfig(t *testing.T) {
+
+	var hexprvkey = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
+	var hexnodekey = "75138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c"
+
+	prvkey, err := crypto.HexToECDSA(hexprvkey)
+	if err != nil {
+		t.Fatalf("failed to load private key: %v", err)
+	}
+	nodekey, err := crypto.HexToECDSA(hexnodekey)
+	if err != nil {
+		t.Fatalf("failed to load private key: %v", err)
+	}
+
+	one := NewConfig()
+	two := NewConfig()
+
+	if equal := reflect.DeepEqual(one, two); !equal {
+		t.Fatal("Two default configs are not equal")
+	}
+
+	err = one.Init(prvkey, nodekey)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	//the init function should set the following fields
+	if one.BzzKey == "" {
+		t.Fatal("Expected BzzKey to be set")
+	}
+	if one.PublicKey == "" {
+		t.Fatal("Expected PublicKey to be set")
+	}
+	if one.Swap.PayProfile.Beneficiary == (common.Address{}) && one.SwapEnabled {
+		t.Fatal("Failed to correctly initialize SwapParams")
+	}
+	if one.ChunkDbPath == one.Path {
+		t.Fatal("Failed to correctly initialize StoreParams")
+	}
+}
--- a/api/encrypt.go
+++ b/api/encrypt.go
@ -0,0 +1,78 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"encoding/binary"
+	"errors"
+
+	"github.com/ethersphere/swarm/storage/encryption"
+	"golang.org/x/crypto/sha3"
+)
+
+type RefEncryption struct {
+	refSize int
+	span    []byte
+}
+
+func NewRefEncryption(refSize int) *RefEncryption {
+	span := make([]byte, 8)
+	binary.LittleEndian.PutUint64(span, uint64(refSize))
+	return &RefEncryption{
+		refSize: refSize,
+		span:    span,
+	}
+}
+
+func (re *RefEncryption) Encrypt(ref []byte, key []byte) ([]byte, error) {
+	spanEncryption := encryption.New(key, 0, uint32(re.refSize/32), sha3.NewLegacyKeccak256)
+	encryptedSpan, err := spanEncryption.Encrypt(re.span)
+	if err != nil {
+		return nil, err
+	}
+	dataEncryption := encryption.New(key, re.refSize, 0, sha3.NewLegacyKeccak256)
+	encryptedData, err := dataEncryption.Encrypt(ref)
+	if err != nil {
+		return nil, err
+	}
+	encryptedRef := make([]byte, len(ref)+8)
+	copy(encryptedRef[:8], encryptedSpan)
+	copy(encryptedRef[8:], encryptedData)
+
+	return encryptedRef, nil
+}
+
+func (re *RefEncryption) Decrypt(ref []byte, key []byte) ([]byte, error) {
+	spanEncryption := encryption.New(key, 0, uint32(re.refSize/32), sha3.NewLegacyKeccak256)
+	decryptedSpan, err := spanEncryption.Decrypt(ref[:8])
+	if err != nil {
+		return nil, err
+	}
+
+	size := binary.LittleEndian.Uint64(decryptedSpan)
+	if size != uint64(len(ref)-8) {
+		return nil, errors.New("invalid span in encrypted reference")
+	}
+
+	dataEncryption := encryption.New(key, re.refSize, 0, sha3.NewLegacyKeccak256)
+	decryptedRef, err := dataEncryption.Decrypt(ref[8:])
+	if err != nil {
+		return nil, err
+	}
+
+	return decryptedRef, nil
+}
--- a/api/filesystem.go
+++ b/api/filesystem.go
@ -0,0 +1,292 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"sync"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/storage"
+)
+
+const maxParallelFiles = 5
+
+type FileSystem struct {
+	api *API
+}
+
+func NewFileSystem(api *API) *FileSystem {
+	return &FileSystem{api}
+}
+
+// Upload replicates a local directory as a manifest file and uploads it
+// using FileStore store
+// This function waits the chunks to be stored.
+// TODO: localpath should point to a manifest
+//
+// DEPRECATED: Use the HTTP API instead
+func (fs *FileSystem) Upload(lpath, index string, toEncrypt bool) (string, error) {
+	var list []*manifestTrieEntry
+	localpath, err := filepath.Abs(filepath.Clean(lpath))
+	if err != nil {
+		return "", err
+	}
+
+	f, err := os.Open(localpath)
+	if err != nil {
+		return "", err
+	}
+	stat, err := f.Stat()
+	if err != nil {
+		return "", err
+	}
+
+	var start int
+	if stat.IsDir() {
+		start = len(localpath)
+		log.Debug(fmt.Sprintf("uploading '%s'", localpath))
+		err = filepath.Walk(localpath, func(path string, info os.FileInfo, err error) error {
+			if (err == nil) && !info.IsDir() {
+				if len(path) <= start {
+					return fmt.Errorf("Path is too short")
+				}
+				if path[:start] != localpath {
+					return fmt.Errorf("Path prefix of '%s' does not match localpath '%s'", path, localpath)
+				}
+				entry := newManifestTrieEntry(&ManifestEntry{Path: filepath.ToSlash(path)}, nil)
+				list = append(list, entry)
+			}
+			return err
+		})
+		if err != nil {
+			return "", err
+		}
+	} else {
+		dir := filepath.Dir(localpath)
+		start = len(dir)
+		if len(localpath) <= start {
+			return "", fmt.Errorf("Path is too short")
+		}
+		if localpath[:start] != dir {
+			return "", fmt.Errorf("Path prefix of '%s' does not match dir '%s'", localpath, dir)
+		}
+		entry := newManifestTrieEntry(&ManifestEntry{Path: filepath.ToSlash(localpath)}, nil)
+		list = append(list, entry)
+	}
+
+	errors := make([]error, len(list))
+	sem := make(chan bool, maxParallelFiles)
+	defer close(sem)
+
+	for i, entry := range list {
+		sem <- true
+		go func(i int, entry *manifestTrieEntry) {
+			defer func() { <-sem }()
+
+			f, err := os.Open(entry.Path)
+			if err != nil {
+				errors[i] = err
+				return
+			}
+			defer f.Close()
+
+			stat, err := f.Stat()
+			if err != nil {
+				errors[i] = err
+				return
+			}
+
+			var hash storage.Address
+			var wait func(context.Context) error
+			ctx := context.TODO()
+			hash, wait, err = fs.api.fileStore.Store(ctx, f, stat.Size(), toEncrypt)
+			if err != nil {
+				errors[i] = err
+				return
+			}
+			if hash != nil {
+				list[i].Hash = hash.Hex()
+			}
+			if err := wait(ctx); err != nil {
+				errors[i] = err
+				return
+			}
+
+			list[i].ContentType, err = DetectContentType(f.Name(), f)
+			if err != nil {
+				errors[i] = err
+				return
+			}
+
+		}(i, entry)
+	}
+	for i := 0; i < cap(sem); i++ {
+		sem <- true
+	}
+
+	trie := &manifestTrie{
+		fileStore: fs.api.fileStore,
+	}
+	quitC := make(chan bool)
+	for i, entry := range list {
+		if errors[i] != nil {
+			return "", errors[i]
+		}
+		entry.Path = RegularSlashes(entry.Path[start:])
+		if entry.Path == index {
+			ientry := newManifestTrieEntry(&ManifestEntry{
+				ContentType: entry.ContentType,
+			}, nil)
+			ientry.Hash = entry.Hash
+			trie.addEntry(ientry, quitC)
+		}
+		trie.addEntry(entry, quitC)
+	}
+
+	err2 := trie.recalcAndStore()
+	var hs string
+	if err2 == nil {
+		hs = trie.ref.Hex()
+	}
+	return hs, err2
+}
+
+// Download replicates the manifest basePath structure on the local filesystem
+// under localpath
+//
+// DEPRECATED: Use the HTTP API instead
+func (fs *FileSystem) Download(bzzpath, localpath string) error {
+	lpath, err := filepath.Abs(filepath.Clean(localpath))
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(lpath, os.ModePerm)
+	if err != nil {
+		return err
+	}
+
+	//resolving host and port
+	uri, err := Parse(path.Join("bzz:/", bzzpath))
+	if err != nil {
+		return err
+	}
+	addr, err := fs.api.Resolve(context.TODO(), uri.Addr)
+	if err != nil {
+		return err
+	}
+	path := uri.Path
+
+	if len(path) > 0 {
+		path += "/"
+	}
+
+	quitC := make(chan bool)
+	trie, err := loadManifest(context.TODO(), fs.api.fileStore, addr, quitC, NOOPDecrypt)
+	if err != nil {
+		log.Warn(fmt.Sprintf("fs.Download: loadManifestTrie error: %v", err))
+		return err
+	}
+
+	type downloadListEntry struct {
+		addr storage.Address
+		path string
+	}
+
+	var list []*downloadListEntry
+	var mde error
+
+	prevPath := lpath
+	err = trie.listWithPrefix(path, quitC, func(entry *manifestTrieEntry, suffix string) {
+		log.Trace(fmt.Sprintf("fs.Download: %#v", entry))
+
+		addr = common.Hex2Bytes(entry.Hash)
+		path := lpath + "/" + suffix
+		dir := filepath.Dir(path)
+		if dir != prevPath {
+			mde = os.MkdirAll(dir, os.ModePerm)
+			prevPath = dir
+		}
+		if (mde == nil) && (path != dir+"/") {
+			list = append(list, &downloadListEntry{addr: addr, path: path})
+		}
+	})
+	if err != nil {
+		return err
+	}
+
+	wg := sync.WaitGroup{}
+	errC := make(chan error)
+	done := make(chan bool, maxParallelFiles)
+	for i, entry := range list {
+		select {
+		case done <- true:
+			wg.Add(1)
+		case <-quitC:
+			return fmt.Errorf("aborted")
+		}
+		go func(i int, entry *downloadListEntry) {
+			defer wg.Done()
+			err := retrieveToFile(quitC, fs.api.fileStore, entry.addr, entry.path)
+			if err != nil {
+				select {
+				case errC <- err:
+				case <-quitC:
+				}
+				return
+			}
+			<-done
+		}(i, entry)
+	}
+	go func() {
+		wg.Wait()
+		close(errC)
+	}()
+	select {
+	case err = <-errC:
+		return err
+	case <-quitC:
+		return fmt.Errorf("aborted")
+	}
+}
+
+func retrieveToFile(quitC chan bool, fileStore *storage.FileStore, addr storage.Address, path string) error {
+	f, err := os.Create(path) // TODO: basePath separators
+	if err != nil {
+		return err
+	}
+	reader, _ := fileStore.Retrieve(context.TODO(), addr)
+	writer := bufio.NewWriter(f)
+	size, err := reader.Size(context.TODO(), quitC)
+	if err != nil {
+		return err
+	}
+	if _, err = io.CopyN(writer, reader, size); err != nil {
+		return err
+	}
+	if err := writer.Flush(); err != nil {
+		return err
+	}
+	return f.Close()
+}
--- a/api/filesystem_test.go
+++ b/api/filesystem_test.go
@ -0,0 +1,203 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/storage"
+)
+
+func testFileSystem(t *testing.T, f func(*FileSystem, bool)) {
+	testAPI(t, func(api *API, _ *chunk.Tags, toEncrypt bool) {
+		f(NewFileSystem(api), toEncrypt)
+	})
+}
+
+func readPath(t *testing.T, parts ...string) string {
+	file := filepath.Join(parts...)
+	content, err := ioutil.ReadFile(file)
+
+	if err != nil {
+		t.Fatalf("unexpected error reading '%v': %v", file, err)
+	}
+	return string(content)
+}
+
+func TestApiDirUpload0(t *testing.T) {
+	testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
+		api := fs.api
+		bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "", toEncrypt)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		content := readPath(t, "testdata", "test0", "index.html")
+		resp := testGet(t, api, bzzhash, "index.html")
+		exp := expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+
+		content = readPath(t, "testdata", "test0", "index.css")
+		resp = testGet(t, api, bzzhash, "index.css")
+		exp = expResponse(content, "text/css; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+
+		addr := storage.Address(common.Hex2Bytes(bzzhash))
+		_, _, _, _, err = api.Get(context.TODO(), NOOPDecrypt, addr, "")
+		if err == nil {
+			t.Fatalf("expected error: %v", err)
+		}
+
+		testDownloadDir, err := ioutil.TempDir(os.TempDir(), "bzz-test")
+		downloadDir := filepath.Join(testDownloadDir, "test0")
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		defer os.RemoveAll(downloadDir)
+
+		err = fs.Download(bzzhash, downloadDir)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		newbzzhash, err := fs.Upload(downloadDir, "", toEncrypt)
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		// TODO: currently the hash is not deterministic in the encrypted case
+		if !toEncrypt && bzzhash != newbzzhash {
+			t.Fatalf("download %v reuploaded has incorrect hash, expected %v, got %v", downloadDir, bzzhash, newbzzhash)
+		}
+	})
+}
+
+func TestApiDirUploadModify(t *testing.T) {
+	testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
+		api := fs.api
+		bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "", toEncrypt)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+
+		addr := storage.Address(common.Hex2Bytes(bzzhash))
+		addr, err = api.Modify(context.TODO(), addr, "index.html", "", "")
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		index, err := ioutil.ReadFile(filepath.Join("testdata", "test0", "index.html"))
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		ctx := context.TODO()
+		hash, wait, err := api.Store(ctx, bytes.NewReader(index), int64(len(index)), toEncrypt)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		err = wait(ctx)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		addr, err = api.Modify(context.TODO(), addr, "index2.html", hash.Hex(), "text/html; charset=utf-8")
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		addr, err = api.Modify(context.TODO(), addr, "img/logo.png", hash.Hex(), "text/html; charset=utf-8")
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+		bzzhash = addr.Hex()
+
+		content := readPath(t, "testdata", "test0", "index.html")
+		resp := testGet(t, api, bzzhash, "index2.html")
+		exp := expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+
+		resp = testGet(t, api, bzzhash, "img/logo.png")
+		exp = expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+
+		content = readPath(t, "testdata", "test0", "index.css")
+		resp = testGet(t, api, bzzhash, "index.css")
+		exp = expResponse(content, "text/css; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+
+		_, _, _, _, err = api.Get(context.TODO(), nil, addr, "")
+		if err == nil {
+			t.Errorf("expected error: %v", err)
+		}
+	})
+}
+
+func TestApiDirUploadWithRootFile(t *testing.T) {
+	testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
+		api := fs.api
+		bzzhash, err := fs.Upload(filepath.Join("testdata", "test0"), "index.html", toEncrypt)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+
+		content := readPath(t, "testdata", "test0", "index.html")
+		resp := testGet(t, api, bzzhash, "")
+		exp := expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+	})
+}
+
+func TestApiFileUpload(t *testing.T) {
+	testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
+		api := fs.api
+		bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "", toEncrypt)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+
+		content := readPath(t, "testdata", "test0", "index.html")
+		resp := testGet(t, api, bzzhash, "index.html")
+		exp := expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+	})
+}
+
+func TestApiFileUploadWithRootFile(t *testing.T) {
+	testFileSystem(t, func(fs *FileSystem, toEncrypt bool) {
+		api := fs.api
+		bzzhash, err := fs.Upload(filepath.Join("testdata", "test0", "index.html"), "index.html", toEncrypt)
+		if err != nil {
+			t.Errorf("unexpected error: %v", err)
+			return
+		}
+
+		content := readPath(t, "testdata", "test0", "index.html")
+		resp := testGet(t, api, bzzhash, "")
+		exp := expResponse(content, "text/html; charset=utf-8", 0)
+		checkResponse(t, resp, exp)
+	})
+}
--- a/api/gen_mime.go
+++ b/api/gen_mime.go
--- a/api/http/middleware.go
+++ b/api/http/middleware.go
@ -0,0 +1,162 @@
+package http
+
+import (
+	"fmt"
+	"net/http"
+	"runtime/debug"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/api"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/sctx"
+	"github.com/ethersphere/swarm/spancontext"
+	"github.com/pborman/uuid"
+)
+
+// Adapt chains h (main request handler) main handler to adapters (middleware handlers)
+// Please note that the order of execution for `adapters` is FIFO (adapters[0] will be executed first)
+func Adapt(h http.Handler, adapters ...Adapter) http.Handler {
+	for i := range adapters {
+		adapter := adapters[len(adapters)-1-i]
+		h = adapter(h)
+	}
+	return h
+}
+
+type Adapter func(http.Handler) http.Handler
+
+func SetRequestID(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		r = r.WithContext(SetRUID(r.Context(), uuid.New()[:8]))
+		metrics.GetOrRegisterCounter(fmt.Sprintf("http.request.%s", r.Method), nil).Inc(1)
+		log.Info("created ruid for request", "ruid", GetRUID(r.Context()), "method", r.Method, "url", r.RequestURI)
+
+		h.ServeHTTP(w, r)
+	})
+}
+
+func SetRequestHost(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		r = r.WithContext(sctx.SetHost(r.Context(), r.Host))
+		log.Info("setting request host", "ruid", GetRUID(r.Context()), "host", sctx.GetHost(r.Context()))
+
+		h.ServeHTTP(w, r)
+	})
+}
+
+func ParseURI(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		uri, err := api.Parse(strings.TrimLeft(r.URL.Path, "/"))
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest)
+			respondError(w, r, fmt.Sprintf("invalid URI %q", r.URL.Path), http.StatusBadRequest)
+			return
+		}
+		if uri.Addr != "" && strings.HasPrefix(uri.Addr, "0x") {
+			uri.Addr = strings.TrimPrefix(uri.Addr, "0x")
+
+			msg := fmt.Sprintf(`The requested hash seems to be prefixed with '0x'. You will be redirected to the correct URL within 5 seconds.<br/>
+			Please click <a href='%[1]s'>here</a> if your browser does not redirect you within 5 seconds.<script>setTimeout("location.href='%[1]s';",5000);</script>`, "/"+uri.String())
+			w.WriteHeader(http.StatusNotFound)
+			w.Write([]byte(msg))
+			return
+		}
+
+		ctx := r.Context()
+		r = r.WithContext(SetURI(ctx, uri))
+		log.Debug("parsed request path", "ruid", GetRUID(r.Context()), "method", r.Method, "uri.Addr", uri.Addr, "uri.Path", uri.Path, "uri.Scheme", uri.Scheme)
+
+		h.ServeHTTP(w, r)
+	})
+}
+
+func InitLoggingResponseWriter(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		tn := time.Now()
+
+		writer := newLoggingResponseWriter(w)
+		h.ServeHTTP(writer, r)
+
+		ts := time.Since(tn)
+		log.Info("request served", "ruid", GetRUID(r.Context()), "code", writer.statusCode, "time", ts)
+		metrics.GetOrRegisterResettingTimer(fmt.Sprintf("http.request.%s.time", r.Method), nil).Update(ts)
+		metrics.GetOrRegisterResettingTimer(fmt.Sprintf("http.request.%s.%d.time", r.Method, writer.statusCode), nil).Update(ts)
+	})
+}
+
+// InitUploadTag creates a new tag for an upload to the local HTTP proxy
+// if a tag is not named using the SwarmTagHeaderName, a fallback name will be used
+// when the Content-Length header is set, an ETA on chunking will be available since the
+// number of chunks to be split is known in advance (not including enclosing manifest chunks)
+// the tag can later be accessed using the appropriate identifier in the request context
+func InitUploadTag(h http.Handler, tags *chunk.Tags) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var (
+			tagName        string
+			err            error
+			estimatedTotal int64 = 0
+			contentType          = r.Header.Get("Content-Type")
+			headerTag            = r.Header.Get(SwarmTagHeaderName)
+		)
+		if headerTag != "" {
+			tagName = headerTag
+			log.Trace("got tag name from http header", "tagName", tagName)
+		} else {
+			tagName = fmt.Sprintf("unnamed_tag_%d", time.Now().Unix())
+		}
+
+		if !strings.Contains(contentType, "multipart") && r.ContentLength > 0 {
+			log.Trace("calculating tag size", "contentType", contentType, "contentLength", r.ContentLength)
+			uri := GetURI(r.Context())
+			if uri != nil {
+				log.Debug("got uri from context")
+				if uri.Addr == "encrypt" {
+					estimatedTotal = calculateNumberOfChunks(r.ContentLength, true)
+				} else {
+					estimatedTotal = calculateNumberOfChunks(r.ContentLength, false)
+				}
+			}
+		}
+
+		log.Trace("creating tag", "tagName", tagName, "estimatedTotal", estimatedTotal)
+
+		t, err := tags.New(tagName, estimatedTotal)
+		if err != nil {
+			log.Error("error creating tag", "err", err, "tagName", tagName)
+		}
+
+		log.Trace("setting tag id to context", "uid", t.Uid)
+		ctx := sctx.SetTag(r.Context(), t.Uid)
+
+		h.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func InstrumentOpenTracing(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		uri := GetURI(r.Context())
+		if uri == nil || r.Method == "" || (uri != nil && uri.Scheme == "") {
+			h.ServeHTTP(w, r) // soft fail
+			return
+		}
+		spanName := fmt.Sprintf("http.%s.%s", r.Method, uri.Scheme)
+		ctx, sp := spancontext.StartSpan(r.Context(), spanName)
+
+		defer sp.Finish()
+		h.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func RecoverPanic(h http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if err := recover(); err != nil {
+				log.Error("panic recovery!", "stack trace", string(debug.Stack()), "url", r.URL.String(), "headers", r.Header)
+			}
+		}()
+		h.ServeHTTP(w, r)
+	})
+}
--- a/api/http/response.go
+++ b/api/http/response.go
@ -0,0 +1,132 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/api"
+)
+
+var (
+	htmlCounter      = metrics.NewRegisteredCounter("api.http.errorpage.html.count", nil)
+	jsonCounter      = metrics.NewRegisteredCounter("api.http.errorpage.json.count", nil)
+	plaintextCounter = metrics.NewRegisteredCounter("api.http.errorpage.plaintext.count", nil)
+)
+
+type ResponseParams struct {
+	Msg       template.HTML
+	Code      int
+	Timestamp string
+	template  *template.Template
+	Details   template.HTML
+}
+
+// ShowMultipleChoices is used when a user requests a resource in a manifest which results
+// in ambiguous results. It returns a HTML page with clickable links of each of the entry
+// in the manifest which fits the request URI ambiguity.
+// For example, if the user requests bzz:/<hash>/read and that manifest contains entries
+// "readme.md" and "readinglist.txt", a HTML page is returned with this two links.
+// This only applies if the manifest has no default entry
+func ShowMultipleChoices(w http.ResponseWriter, r *http.Request, list api.ManifestList) {
+	log.Debug("ShowMultipleChoices", "ruid", GetRUID(r.Context()), "uri", GetURI(r.Context()))
+	msg := ""
+	if list.Entries == nil {
+		respondError(w, r, "Could not resolve", http.StatusInternalServerError)
+		return
+	}
+	requestUri := strings.TrimPrefix(r.RequestURI, "/")
+
+	uri, err := api.Parse(requestUri)
+	if err != nil {
+		respondError(w, r, "Bad Request", http.StatusBadRequest)
+	}
+
+	uri.Scheme = "bzz-list"
+	msg += fmt.Sprintf("Disambiguation:<br/>Your request may refer to multiple choices.<br/>Click <a class=\"orange\" href='"+"/"+uri.String()+"'>here</a> if your browser does not redirect you within 5 seconds.<script>setTimeout(\"location.href='%s';\",5000);</script><br/>", "/"+uri.String())
+	respondTemplate(w, r, "error", msg, http.StatusMultipleChoices)
+}
+
+func respondTemplate(w http.ResponseWriter, r *http.Request, templateName, msg string, code int) {
+	log.Debug("respondTemplate", "ruid", GetRUID(r.Context()), "uri", GetURI(r.Context()))
+	respond(w, r, &ResponseParams{
+		Code:      code,
+		Msg:       template.HTML(msg),
+		Timestamp: time.Now().Format(time.RFC1123),
+		template:  TemplatesMap[templateName],
+	})
+}
+
+func respondError(w http.ResponseWriter, r *http.Request, msg string, code int) {
+	log.Info("respondError", "ruid", GetRUID(r.Context()), "uri", GetURI(r.Context()), "code", code, "msg", msg)
+	respondTemplate(w, r, "error", msg, code)
+}
+
+func respond(w http.ResponseWriter, r *http.Request, params *ResponseParams) {
+	w.WriteHeader(params.Code)
+
+	if params.Code >= 400 {
+		w.Header().Del("Cache-Control")
+		w.Header().Del("ETag")
+	}
+
+	acceptHeader := r.Header.Get("Accept")
+	// this cannot be in a switch since an Accept header can have multiple values: "Accept: */*, text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8"
+	if strings.Contains(acceptHeader, "application/json") {
+		if err := respondJSON(w, r, params); err != nil {
+			respondError(w, r, "Internal server error", http.StatusInternalServerError)
+		}
+	} else if strings.Contains(acceptHeader, "text/html") {
+		respondHTML(w, r, params)
+	} else {
+		respondPlaintext(w, r, params) //returns nice errors for curl
+	}
+}
+
+func respondHTML(w http.ResponseWriter, r *http.Request, params *ResponseParams) {
+	htmlCounter.Inc(1)
+	log.Info("respondHTML", "ruid", GetRUID(r.Context()), "code", params.Code)
+	err := params.template.Execute(w, params)
+	if err != nil {
+		log.Error(err.Error())
+	}
+}
+
+func respondJSON(w http.ResponseWriter, r *http.Request, params *ResponseParams) error {
+	jsonCounter.Inc(1)
+	log.Info("respondJSON", "ruid", GetRUID(r.Context()), "code", params.Code)
+	w.Header().Set("Content-Type", "application/json")
+	return json.NewEncoder(w).Encode(params)
+}
+
+func respondPlaintext(w http.ResponseWriter, r *http.Request, params *ResponseParams) error {
+	plaintextCounter.Inc(1)
+	log.Info("respondPlaintext", "ruid", GetRUID(r.Context()), "code", params.Code)
+	w.Header().Set("Content-Type", "text/plain")
+	strToWrite := "Code: " + fmt.Sprintf("%d", params.Code) + "\n"
+	strToWrite += "Message: " + string(params.Msg) + "\n"
+	strToWrite += "Timestamp: " + params.Timestamp + "\n"
+	_, err := w.Write([]byte(strToWrite))
+	return err
+}
--- a/api/http/response_test.go
+++ b/api/http/response_test.go
@ -0,0 +1,170 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package http
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+
+	"golang.org/x/net/html"
+)
+
+func TestError(t *testing.T) {
+	srv := NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	var resp *http.Response
+	var respbody []byte
+
+	url := srv.URL + "/this_should_fail_as_no_bzz_protocol_present"
+	resp, err := http.Get(url)
+
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	defer resp.Body.Close()
+	respbody, err = ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 404 && !strings.Contains(string(respbody), "Invalid URI &#34;/this_should_fail_as_no_bzz_protocol_present&#34;: unknown scheme") {
+		t.Fatalf("Response body does not match, expected: %v, to contain: %v; received code %d, expected code: %d", string(respbody), "Invalid bzz URI: unknown scheme", 400, resp.StatusCode)
+	}
+
+	_, err = html.Parse(strings.NewReader(string(respbody)))
+	if err != nil {
+		t.Fatalf("HTML validation failed for error page returned!")
+	}
+}
+
+func Test404Page(t *testing.T) {
+	srv := NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	var resp *http.Response
+	var respbody []byte
+
+	url := srv.URL + "/bzz:/1234567890123456789012345678901234567890123456789012345678901234"
+	resp, err := http.Get(url)
+
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	defer resp.Body.Close()
+	respbody, err = ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 404 || !strings.Contains(string(respbody), "404") {
+		t.Fatalf("Invalid Status Code received, expected 404, got %d", resp.StatusCode)
+	}
+
+	_, err = html.Parse(strings.NewReader(string(respbody)))
+	if err != nil {
+		t.Fatalf("HTML validation failed for error page returned!")
+	}
+}
+
+func Test500Page(t *testing.T) {
+	srv := NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	var resp *http.Response
+	var respbody []byte
+
+	url := srv.URL + "/bzz:/thisShouldFailWith500Code"
+	resp, err := http.Get(url)
+
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	defer resp.Body.Close()
+	respbody, err = ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 404 {
+		t.Fatalf("Invalid Status Code received, expected 404, got %d", resp.StatusCode)
+	}
+
+	_, err = html.Parse(strings.NewReader(string(respbody)))
+	if err != nil {
+		t.Fatalf("HTML validation failed for error page returned!")
+	}
+}
+func Test500PageWith0xHashPrefix(t *testing.T) {
+	srv := NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	var resp *http.Response
+	var respbody []byte
+
+	url := srv.URL + "/bzz:/0xthisShouldFailWith500CodeAndAHelpfulMessage"
+	resp, err := http.Get(url)
+
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	defer resp.Body.Close()
+	respbody, err = ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 404 {
+		t.Fatalf("Invalid Status Code received, expected 404, got %d", resp.StatusCode)
+	}
+
+	if !strings.Contains(string(respbody), "The requested hash seems to be prefixed with") {
+		t.Fatalf("Did not receive the expected error message")
+	}
+
+	_, err = html.Parse(strings.NewReader(string(respbody)))
+	if err != nil {
+		t.Fatalf("HTML validation failed for error page returned!")
+	}
+}
+
+func TestJsonResponse(t *testing.T) {
+	srv := NewTestSwarmServer(t, serverFunc, nil)
+	defer srv.Close()
+
+	var resp *http.Response
+	var respbody []byte
+
+	url := srv.URL + "/bzz:/thisShouldFailWith500Code/"
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+	req.Header.Set("Accept", "application/json")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatalf("Request failed: %v", err)
+	}
+
+	defer resp.Body.Close()
+	respbody, err = ioutil.ReadAll(resp.Body)
+
+	if resp.StatusCode != 404 {
+		t.Fatalf("Invalid Status Code received, expected 404, got %d", resp.StatusCode)
+	}
+
+	if !isJSON(string(respbody)) {
+		t.Fatalf("Expected response to be JSON, received invalid JSON: %s", string(respbody))
+	}
+
+}
+
+func isJSON(s string) bool {
+	var js map[string]interface{}
+	return json.Unmarshal([]byte(s), &js) == nil
+}
--- a/api/http/roundtripper.go
+++ b/api/http/roundtripper.go
@ -0,0 +1,66 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package http
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/ethersphere/swarm/log"
+)
+
+/*
+http roundtripper to register for bzz url scheme
+see https://github.com/ethereum/go-ethereum/issues/2040
+Usage:
+
+import (
+ "github.com/ethereum/go-ethereum/common/httpclient"
+ "github.com/ethersphere/swarm/api/http"
+)
+client := httpclient.New()
+// for (private) swarm proxy running locally
+client.RegisterScheme("bzz", &http.RoundTripper{Port: port})
+client.RegisterScheme("bzz-immutable", &http.RoundTripper{Port: port})
+client.RegisterScheme("bzz-raw", &http.RoundTripper{Port: port})
+
+The port you give the Roundtripper is the port the swarm proxy is listening on.
+If Host is left empty, localhost is assumed.
+
+Using a public gateway, the above few lines gives you the leanest
+bzz-scheme aware read-only http client. You really only ever need this
+if you need go-native swarm access to bzz addresses.
+*/
+
+type RoundTripper struct {
+	Host string
+	Port string
+}
+
+func (self *RoundTripper) RoundTrip(req *http.Request) (resp *http.Response, err error) {
+	host := self.Host
+	if len(host) == 0 {
+		host = "localhost"
+	}
+	url := fmt.Sprintf("http://%s:%s/%s:/%s/%s", host, self.Port, req.Proto, req.URL.Host, req.URL.Path)
+	log.Info(fmt.Sprintf("roundtripper: proxying request '%s' to '%s'", req.RequestURI, url))
+	reqProxy, err := http.NewRequest(req.Method, url, req.Body)
+	if err != nil {
+		return nil, err
+	}
+	return http.DefaultClient.Do(reqProxy)
+}
--- a/api/http/roundtripper_test.go
+++ b/api/http/roundtripper_test.go
@ -0,0 +1,69 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package http
+
+import (
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestRoundTripper(t *testing.T) {
+	serveMux := http.NewServeMux()
+	serveMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if r.Method == "GET" {
+			w.Header().Set("Content-Type", "text/plain")
+			http.ServeContent(w, r, "", time.Unix(0, 0), strings.NewReader(r.RequestURI))
+		} else {
+			http.Error(w, "Method "+r.Method+" is not supported.", http.StatusMethodNotAllowed)
+		}
+	})
+
+	srv := httptest.NewServer(serveMux)
+	defer srv.Close()
+
+	host, port, _ := net.SplitHostPort(srv.Listener.Addr().String())
+	rt := &RoundTripper{Host: host, Port: port}
+	trans := &http.Transport{}
+	trans.RegisterProtocol("bzz", rt)
+	client := &http.Client{Transport: trans}
+	resp, err := client.Get("bzz://test.com/path")
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+		return
+	}
+
+	defer func() {
+		if resp != nil {
+			resp.Body.Close()
+		}
+	}()
+
+	content, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+		return
+	}
+	if string(content) != "/HTTP/1.1:/test.com/path" {
+		t.Errorf("incorrect response from http server: expected '%v', got '%v'", "/HTTP/1.1:/test.com/path", string(content))
+	}
+
+}
--- a/api/http/sctx.go
+++ b/api/http/sctx.go
@ -0,0 +1,34 @@
+package http
+
+import (
+	"context"
+
+	"github.com/ethersphere/swarm/api"
+	"github.com/ethersphere/swarm/sctx"
+)
+
+type uriKey struct{}
+
+func GetRUID(ctx context.Context) string {
+	v, ok := ctx.Value(sctx.HTTPRequestIDKey{}).(string)
+	if ok {
+		return v
+	}
+	return "xxxxxxxx"
+}
+
+func SetRUID(ctx context.Context, ruid string) context.Context {
+	return context.WithValue(ctx, sctx.HTTPRequestIDKey{}, ruid)
+}
+
+func GetURI(ctx context.Context) *api.URI {
+	v, ok := ctx.Value(uriKey{}).(*api.URI)
+	if ok {
+		return v
+	}
+	return nil
+}
+
+func SetURI(ctx context.Context, uri *api.URI) context.Context {
+	return context.WithValue(ctx, uriKey{}, uri)
+}
--- a/api/http/server.go
+++ b/api/http/server.go
@ -0,0 +1,937 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+/*
+A simple http server interface to Swarm
+*/
+package http
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"mime"
+	"mime/multipart"
+	"net/http"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/api"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/sctx"
+	"github.com/ethersphere/swarm/storage"
+	"github.com/ethersphere/swarm/storage/feed"
+	"github.com/rs/cors"
+)
+
+var (
+	postRawCount    = metrics.NewRegisteredCounter("api.http.post.raw.count", nil)
+	postRawFail     = metrics.NewRegisteredCounter("api.http.post.raw.fail", nil)
+	postFilesCount  = metrics.NewRegisteredCounter("api.http.post.files.count", nil)
+	postFilesFail   = metrics.NewRegisteredCounter("api.http.post.files.fail", nil)
+	deleteCount     = metrics.NewRegisteredCounter("api.http.delete.count", nil)
+	deleteFail      = metrics.NewRegisteredCounter("api.http.delete.fail", nil)
+	getCount        = metrics.NewRegisteredCounter("api.http.get.count", nil)
+	getFail         = metrics.NewRegisteredCounter("api.http.get.fail", nil)
+	getFileCount    = metrics.NewRegisteredCounter("api.http.get.file.count", nil)
+	getFileNotFound = metrics.NewRegisteredCounter("api.http.get.file.notfound", nil)
+	getFileFail     = metrics.NewRegisteredCounter("api.http.get.file.fail", nil)
+	getListCount    = metrics.NewRegisteredCounter("api.http.get.list.count", nil)
+	getListFail     = metrics.NewRegisteredCounter("api.http.get.list.fail", nil)
+)
+
+const SwarmTagHeaderName = "x-swarm-tag"
+
+type methodHandler map[string]http.Handler
+
+func (m methodHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
+	v, ok := m[r.Method]
+	if ok {
+		v.ServeHTTP(rw, r)
+		return
+	}
+	rw.WriteHeader(http.StatusMethodNotAllowed)
+}
+
+func NewServer(api *api.API, corsString string) *Server {
+	var allowedOrigins []string
+	for _, domain := range strings.Split(corsString, ",") {
+		allowedOrigins = append(allowedOrigins, strings.TrimSpace(domain))
+	}
+	c := cors.New(cors.Options{
+		AllowedOrigins: allowedOrigins,
+		AllowedMethods: []string{http.MethodPost, http.MethodGet, http.MethodDelete, http.MethodPatch, http.MethodPut},
+		MaxAge:         600,
+		AllowedHeaders: []string{"*"},
+	})
+
+	server := &Server{api: api}
+
+	defaultMiddlewares := []Adapter{
+		RecoverPanic,
+		SetRequestID,
+		SetRequestHost,
+		InitLoggingResponseWriter,
+		ParseURI,
+		InstrumentOpenTracing,
+	}
+
+	tagAdapter := Adapter(func(h http.Handler) http.Handler {
+		return InitUploadTag(h, api.Tags)
+	})
+
+	defaultPostMiddlewares := append(defaultMiddlewares, tagAdapter)
+
+	mux := http.NewServeMux()
+	mux.Handle("/bzz:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleBzzGet),
+			defaultMiddlewares...,
+		),
+		"POST": Adapt(
+			http.HandlerFunc(server.HandlePostFiles),
+			defaultPostMiddlewares...,
+		),
+		"DELETE": Adapt(
+			http.HandlerFunc(server.HandleDelete),
+			defaultMiddlewares...,
+		),
+	})
+	mux.Handle("/bzz-raw:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleGet),
+			defaultMiddlewares...,
+		),
+		"POST": Adapt(
+			http.HandlerFunc(server.HandlePostRaw),
+			defaultPostMiddlewares...,
+		),
+	})
+	mux.Handle("/bzz-immutable:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleBzzGet),
+			defaultMiddlewares...,
+		),
+	})
+	mux.Handle("/bzz-hash:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleGet),
+			defaultMiddlewares...,
+		),
+	})
+	mux.Handle("/bzz-list:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleGetList),
+			defaultMiddlewares...,
+		),
+	})
+	mux.Handle("/bzz-feed:/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleGetFeed),
+			defaultMiddlewares...,
+		),
+		"POST": Adapt(
+			http.HandlerFunc(server.HandlePostFeed),
+			defaultMiddlewares...,
+		),
+	})
+
+	mux.Handle("/", methodHandler{
+		"GET": Adapt(
+			http.HandlerFunc(server.HandleRootPaths),
+			SetRequestID,
+			InitLoggingResponseWriter,
+		),
+	})
+	server.Handler = c.Handler(mux)
+
+	return server
+}
+
+func (s *Server) ListenAndServe(addr string) error {
+	s.listenAddr = addr
+	return http.ListenAndServe(addr, s)
+}
+
+// browser API for registering bzz url scheme handlers:
+// https://developer.mozilla.org/en/docs/Web-based_protocol_handlers
+// electron (chromium) api for registering bzz url scheme handlers:
+// https://github.com/atom/electron/blob/master/docs/api/protocol.md
+type Server struct {
+	http.Handler
+	api        *api.API
+	listenAddr string
+}
+
+func (s *Server) HandleBzzGet(w http.ResponseWriter, r *http.Request) {
+	log.Debug("handleBzzGet", "ruid", GetRUID(r.Context()), "uri", r.RequestURI)
+	if r.Header.Get("Accept") == "application/x-tar" {
+		uri := GetURI(r.Context())
+		_, credentials, _ := r.BasicAuth()
+		reader, err := s.api.GetDirectoryTar(r.Context(), s.api.Decryptor(r.Context(), credentials), uri)
+		if err != nil {
+			if isDecryptError(err) {
+				w.Header().Set("WWW-Authenticate", fmt.Sprintf("Basic realm=%q", uri.Address().String()))
+				respondError(w, r, err.Error(), http.StatusUnauthorized)
+				return
+			}
+			respondError(w, r, fmt.Sprintf("Had an error building the tarball: %v", err), http.StatusInternalServerError)
+			return
+		}
+		defer reader.Close()
+
+		w.Header().Set("Content-Type", "application/x-tar")
+
+		fileName := uri.Addr
+		if found := path.Base(uri.Path); found != "" && found != "." && found != "/" {
+			fileName = found
+		}
+		w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=\"%s.tar\"", fileName))
+
+		w.WriteHeader(http.StatusOK)
+		io.Copy(w, reader)
+		return
+	}
+
+	s.HandleGetFile(w, r)
+}
+
+func (s *Server) HandleRootPaths(w http.ResponseWriter, r *http.Request) {
+	switch r.RequestURI {
+	case "/":
+		respondTemplate(w, r, "landing-page", "Swarm: Please request a valid ENS or swarm hash with the appropriate bzz scheme", 200)
+		return
+	case "/robots.txt":
+		w.Header().Set("Last-Modified", time.Now().Format(http.TimeFormat))
+		fmt.Fprintf(w, "User-agent: *\nDisallow: /")
+	case "/favicon.ico":
+		w.WriteHeader(http.StatusOK)
+		w.Write(faviconBytes)
+	default:
+		respondError(w, r, "Not Found", http.StatusNotFound)
+	}
+}
+
+// HandlePostRaw handles a POST request to a raw bzz-raw:/ URI, stores the request
+// body in swarm and returns the resulting storage address as a text/plain response
+func (s *Server) HandlePostRaw(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	log.Debug("handle.post.raw", "ruid", ruid)
+
+	tagUid := sctx.GetTag(r.Context())
+	tag, err := s.api.Tags.Get(tagUid)
+	if err != nil {
+		log.Error("handle post raw got an error retrieving tag for DoneSplit", "tagUid", tagUid, "err", err)
+	}
+
+	postRawCount.Inc(1)
+
+	toEncrypt := false
+	uri := GetURI(r.Context())
+	if uri.Addr == "encrypt" {
+		toEncrypt = true
+	}
+
+	if uri.Path != "" {
+		postRawFail.Inc(1)
+		respondError(w, r, "raw POST request cannot contain a path", http.StatusBadRequest)
+		return
+	}
+
+	if uri.Addr != "" && uri.Addr != "encrypt" {
+		postRawFail.Inc(1)
+		respondError(w, r, "raw POST request addr can only be empty or \"encrypt\"", http.StatusBadRequest)
+		return
+	}
+
+	if r.Header.Get("Content-Length") == "" {
+		postRawFail.Inc(1)
+		respondError(w, r, "missing Content-Length header in request", http.StatusBadRequest)
+		return
+	}
+
+	addr, wait, err := s.api.Store(r.Context(), r.Body, r.ContentLength, toEncrypt)
+	if err != nil {
+		postRawFail.Inc(1)
+		respondError(w, r, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	wait(r.Context())
+	tag.DoneSplit(addr)
+
+	log.Debug("stored content", "ruid", ruid, "key", addr)
+
+	w.Header().Set("Content-Type", "text/plain")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, addr)
+}
+
+// HandlePostFiles handles a POST request to
+// bzz:/<hash>/<path> which contains either a single file or multiple files
+// (either a tar archive or multipart form), adds those files either to an
+// existing manifest or to a new manifest under <path> and returns the
+// resulting manifest hash as a text/plain response
+func (s *Server) HandlePostFiles(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	log.Debug("handle.post.files", "ruid", ruid)
+	postFilesCount.Inc(1)
+
+	contentType, params, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		postFilesFail.Inc(1)
+		respondError(w, r, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	toEncrypt := false
+	uri := GetURI(r.Context())
+	if uri.Addr == "encrypt" {
+		toEncrypt = true
+	}
+
+	var addr storage.Address
+	if uri.Addr != "" && uri.Addr != "encrypt" {
+		addr, err = s.api.Resolve(r.Context(), uri.Addr)
+		if err != nil {
+			postFilesFail.Inc(1)
+			respondError(w, r, fmt.Sprintf("cannot resolve %s: %s", uri.Addr, err), http.StatusInternalServerError)
+			return
+		}
+		log.Debug("resolved key", "ruid", ruid, "key", addr)
+	} else {
+		addr, err = s.api.NewManifest(r.Context(), toEncrypt)
+		if err != nil {
+			postFilesFail.Inc(1)
+			respondError(w, r, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		log.Debug("new manifest", "ruid", ruid, "key", addr)
+	}
+	newAddr, err := s.api.UpdateManifest(r.Context(), addr, func(mw *api.ManifestWriter) error {
+		switch contentType {
+		case "application/x-tar":
+			_, err := s.handleTarUpload(r, mw)
+			if err != nil {
+				respondError(w, r, fmt.Sprintf("error uploading tarball: %v", err), http.StatusInternalServerError)
+				return err
+			}
+			return nil
+		case "multipart/form-data":
+			return s.handleMultipartUpload(r, params["boundary"], mw)
+
+		default:
+			return s.handleDirectUpload(r, mw)
+		}
+	})
+	if err != nil {
+		postFilesFail.Inc(1)
+		respondError(w, r, fmt.Sprintf("cannot create manifest: %s", err), http.StatusInternalServerError)
+		return
+	}
+
+	tagUid := sctx.GetTag(r.Context())
+	tag, err := s.api.Tags.Get(tagUid)
+	if err != nil {
+		log.Error("got an error retrieving tag for DoneSplit", "tagUid", tagUid, "err", err)
+	}
+
+	log.Debug("done splitting, setting tag total", "SPLIT", tag.Get(chunk.StateSplit), "TOTAL", tag.Total())
+	tag.DoneSplit(newAddr)
+
+	log.Debug("stored content", "ruid", ruid, "key", newAddr)
+
+	w.Header().Set("Content-Type", "text/plain")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, newAddr)
+}
+
+func (s *Server) handleTarUpload(r *http.Request, mw *api.ManifestWriter) (storage.Address, error) {
+	log.Debug("handle.tar.upload", "ruid", GetRUID(r.Context()), "tag", sctx.GetTag(r.Context()))
+
+	defaultPath := r.URL.Query().Get("defaultpath")
+
+	key, err := s.api.UploadTar(r.Context(), r.Body, GetURI(r.Context()).Path, defaultPath, mw)
+	if err != nil {
+		return nil, err
+	}
+	return key, nil
+}
+
+func (s *Server) handleMultipartUpload(r *http.Request, boundary string, mw *api.ManifestWriter) error {
+	ruid := GetRUID(r.Context())
+	log.Debug("handle.multipart.upload", "ruid", ruid)
+	mr := multipart.NewReader(r.Body, boundary)
+	for {
+		part, err := mr.NextPart()
+		if err == io.EOF {
+			return nil
+		} else if err != nil {
+			return fmt.Errorf("error reading multipart form: %s", err)
+		}
+
+		var size int64
+		var reader io.Reader
+		if contentLength := part.Header.Get("Content-Length"); contentLength != "" {
+			size, err = strconv.ParseInt(contentLength, 10, 64)
+			if err != nil {
+				return fmt.Errorf("error parsing multipart content length: %s", err)
+			}
+			reader = part
+		} else {
+			// copy the part to a tmp file to get its size
+			tmp, err := ioutil.TempFile("", "swarm-multipart")
+			if err != nil {
+				return err
+			}
+			defer os.Remove(tmp.Name())
+			defer tmp.Close()
+			size, err = io.Copy(tmp, part)
+			if err != nil {
+				return fmt.Errorf("error copying multipart content: %s", err)
+			}
+			if _, err := tmp.Seek(0, io.SeekStart); err != nil {
+				return fmt.Errorf("error copying multipart content: %s", err)
+			}
+			reader = tmp
+		}
+
+		// add the entry under the path from the request
+		name := part.FileName()
+		if name == "" {
+			name = part.FormName()
+		}
+		uri := GetURI(r.Context())
+		path := path.Join(uri.Path, name)
+		entry := &api.ManifestEntry{
+			Path:        path,
+			ContentType: part.Header.Get("Content-Type"),
+			Size:        size,
+		}
+		log.Debug("adding path to new manifest", "ruid", ruid, "bytes", entry.Size, "path", entry.Path)
+		contentKey, err := mw.AddEntry(r.Context(), reader, entry)
+		if err != nil {
+			return fmt.Errorf("error adding manifest entry from multipart form: %s", err)
+		}
+		log.Debug("stored content", "ruid", ruid, "key", contentKey)
+	}
+}
+
+func (s *Server) handleDirectUpload(r *http.Request, mw *api.ManifestWriter) error {
+	ruid := GetRUID(r.Context())
+	log.Debug("handle.direct.upload", "ruid", ruid)
+	key, err := mw.AddEntry(r.Context(), r.Body, &api.ManifestEntry{
+		Path:        GetURI(r.Context()).Path,
+		ContentType: r.Header.Get("Content-Type"),
+		Mode:        0644,
+		Size:        r.ContentLength,
+	})
+	if err != nil {
+		return err
+	}
+	log.Debug("stored content", "ruid", ruid, "key", key)
+	return nil
+}
+
+// HandleDelete handles a DELETE request to bzz:/<manifest>/<path>, removes
+// <path> from <manifest> and returns the resulting manifest hash as a
+// text/plain response
+func (s *Server) HandleDelete(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	log.Debug("handle.delete", "ruid", ruid)
+	deleteCount.Inc(1)
+	newKey, err := s.api.Delete(r.Context(), uri.Addr, uri.Path)
+	if err != nil {
+		deleteFail.Inc(1)
+		respondError(w, r, fmt.Sprintf("could not delete from manifest: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/plain")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, newKey)
+}
+
+// Handles feed manifest creation and feed updates
+// The POST request admits a JSON structure as defined in the feeds package: `feed.updateRequestJSON`
+// The requests can be to a) create a feed manifest, b) update a feed or c) both a+b: create a feed manifest and publish a first update
+func (s *Server) HandlePostFeed(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	log.Debug("handle.post.feed", "ruid", ruid)
+	var err error
+
+	// Creation and update must send feed.updateRequestJSON JSON structure
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		respondError(w, r, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	fd, err := s.api.ResolveFeed(r.Context(), uri, r.URL.Query())
+	if err != nil { // couldn't parse query string or retrieve manifest
+		getFail.Inc(1)
+		httpStatus := http.StatusBadRequest
+		if err == api.ErrCannotLoadFeedManifest || err == api.ErrCannotResolveFeedURI {
+			httpStatus = http.StatusNotFound
+		}
+		respondError(w, r, fmt.Sprintf("cannot retrieve feed from manifest: %s", err), httpStatus)
+		return
+	}
+
+	var updateRequest feed.Request
+	updateRequest.Feed = *fd
+	query := r.URL.Query()
+
+	if err := updateRequest.FromValues(query, body); err != nil { // decodes request from query parameters
+		respondError(w, r, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	switch {
+	case updateRequest.IsUpdate():
+		// Verify that the signature is intact and that the signer is authorized
+		// to update this feed
+		// Check this early, to avoid creating a feed and then not being able to set its first update.
+		if err = updateRequest.Verify(); err != nil {
+			respondError(w, r, err.Error(), http.StatusForbidden)
+			return
+		}
+		_, err = s.api.FeedsUpdate(r.Context(), &updateRequest)
+		if err != nil {
+			respondError(w, r, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		fallthrough
+	case query.Get("manifest") == "1":
+		// we create a manifest so we can retrieve feed updates with bzz:// later
+		// this manifest has a special "feed type" manifest, and saves the
+		// feed identification used to retrieve feed updates later
+		m, err := s.api.NewFeedManifest(r.Context(), &updateRequest.Feed)
+		if err != nil {
+			respondError(w, r, fmt.Sprintf("failed to create feed manifest: %v", err), http.StatusInternalServerError)
+			return
+		}
+		// the key to the manifest will be passed back to the client
+		// the client can access the feed  directly through its Feed member
+		// the manifest key can be set as content in the resolver of the ENS name
+		outdata, err := json.Marshal(m)
+		if err != nil {
+			respondError(w, r, fmt.Sprintf("failed to create json response: %s", err), http.StatusInternalServerError)
+			return
+		}
+		fmt.Fprint(w, string(outdata))
+
+		w.Header().Add("Content-type", "application/json")
+	default:
+		respondError(w, r, "Missing signature in feed update request", http.StatusBadRequest)
+	}
+}
+
+// HandleGetFeed retrieves Swarm feeds updates:
+// bzz-feed://<manifest address or ENS name> - get latest feed update, given a manifest address
+// - or -
+// specify user + topic (optional), subtopic name (optional) directly, without manifest:
+// bzz-feed://?user=0x...&topic=0x...&name=subtopic name
+// topic defaults to 0x000... if not specified.
+// name defaults to empty string if not specified.
+// thus, empty name and topic refers to the user's default feed.
+//
+// Optional parameters:
+// time=xx - get the latest update before time (in epoch seconds)
+// hint.time=xx - hint the lookup algorithm looking for updates at around that time
+// hint.level=xx - hint the lookup algorithm looking for updates at around this frequency level
+// meta=1 - get feed metadata and status information instead of performing a feed query
+// NOTE: meta=1 will be deprecated in the near future
+func (s *Server) HandleGetFeed(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	log.Debug("handle.get.feed", "ruid", ruid)
+	var err error
+
+	fd, err := s.api.ResolveFeed(r.Context(), uri, r.URL.Query())
+	if err != nil { // couldn't parse query string or retrieve manifest
+		getFail.Inc(1)
+		httpStatus := http.StatusBadRequest
+		if err == api.ErrCannotLoadFeedManifest || err == api.ErrCannotResolveFeedURI {
+			httpStatus = http.StatusNotFound
+		}
+		respondError(w, r, fmt.Sprintf("cannot retrieve feed information from manifest: %s", err), httpStatus)
+		return
+	}
+
+	// determine if the query specifies period and version or it is a metadata query
+	if r.URL.Query().Get("meta") == "1" {
+		unsignedUpdateRequest, err := s.api.FeedsNewRequest(r.Context(), fd)
+		if err != nil {
+			getFail.Inc(1)
+			respondError(w, r, fmt.Sprintf("cannot retrieve feed metadata for feed=%s: %s", fd.Hex(), err), http.StatusNotFound)
+			return
+		}
+		rawResponse, err := unsignedUpdateRequest.MarshalJSON()
+		if err != nil {
+			respondError(w, r, fmt.Sprintf("cannot encode unsigned feed update request: %v", err), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Add("Content-type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		fmt.Fprint(w, string(rawResponse))
+		return
+	}
+
+	lookupParams := &feed.Query{Feed: *fd}
+	if err = lookupParams.FromValues(r.URL.Query()); err != nil { // parse period, version
+		respondError(w, r, fmt.Sprintf("invalid feed update request:%s", err), http.StatusBadRequest)
+		return
+	}
+
+	data, err := s.api.FeedsLookup(r.Context(), lookupParams)
+
+	// any error from the switch statement will end up here
+	if err != nil {
+		code, err2 := s.translateFeedError(w, r, "feed lookup fail", err)
+		respondError(w, r, err2.Error(), code)
+		return
+	}
+
+	// All ok, serve the retrieved update
+	log.Debug("Found update", "feed", fd.Hex(), "ruid", ruid)
+	w.Header().Set("Content-Type", api.MimeOctetStream)
+	http.ServeContent(w, r, "", time.Now(), bytes.NewReader(data))
+}
+
+func (s *Server) translateFeedError(w http.ResponseWriter, r *http.Request, supErr string, err error) (int, error) {
+	code := 0
+	defaultErr := fmt.Errorf("%s: %v", supErr, err)
+	rsrcErr, ok := err.(*feed.Error)
+	if !ok && rsrcErr != nil {
+		code = rsrcErr.Code()
+	}
+	switch code {
+	case storage.ErrInvalidValue:
+		return http.StatusBadRequest, defaultErr
+	case storage.ErrNotFound, storage.ErrNotSynced, storage.ErrNothingToReturn, storage.ErrInit:
+		return http.StatusNotFound, defaultErr
+	case storage.ErrUnauthorized, storage.ErrInvalidSignature:
+		return http.StatusUnauthorized, defaultErr
+	case storage.ErrDataOverflow:
+		return http.StatusRequestEntityTooLarge, defaultErr
+	}
+
+	return http.StatusInternalServerError, defaultErr
+}
+
+// HandleGet handles a GET request to
+// - bzz-raw://<key> and responds with the raw content stored at the
+//   given storage key
+// - bzz-hash://<key> and responds with the hash of the content stored
+//   at the given storage key as a text/plain response
+func (s *Server) HandleGet(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	log.Debug("handle.get", "ruid", ruid, "uri", uri)
+	getCount.Inc(1)
+	_, pass, _ := r.BasicAuth()
+
+	addr, err := s.api.ResolveURI(r.Context(), uri, pass)
+	if err != nil {
+		getFail.Inc(1)
+		respondError(w, r, fmt.Sprintf("cannot resolve %s: %s", uri.Addr, err), http.StatusNotFound)
+		return
+	}
+	w.Header().Set("Cache-Control", "max-age=2147483648, immutable") // url was of type bzz://<hex key>/path, so we are sure it is immutable.
+
+	log.Debug("handle.get: resolved", "ruid", ruid, "key", addr)
+
+	// if path is set, interpret <key> as a manifest and return the
+	// raw entry at the given path
+	etag := common.Bytes2Hex(addr)
+	noneMatchEtag := r.Header.Get("If-None-Match")
+	w.Header().Set("ETag", fmt.Sprintf("%q", etag)) // set etag to manifest key or raw entry key.
+	if noneMatchEtag != "" {
+		if bytes.Equal(storage.Address(common.Hex2Bytes(noneMatchEtag)), addr) {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+	}
+
+	switch {
+	case uri.Raw():
+		// check the root chunk exists by retrieving the file's size
+		reader, isEncrypted := s.api.Retrieve(r.Context(), addr)
+		if _, err := reader.Size(r.Context(), nil); err != nil {
+			getFail.Inc(1)
+			respondError(w, r, fmt.Sprintf("root chunk not found %s: %s", addr, err), http.StatusNotFound)
+			return
+		}
+
+		w.Header().Set("X-Decrypted", fmt.Sprintf("%v", isEncrypted))
+
+		// allow the request to overwrite the content type using a query
+		// parameter
+		if typ := r.URL.Query().Get("content_type"); typ != "" {
+			w.Header().Set("Content-Type", typ)
+		}
+		http.ServeContent(w, r, "", time.Now(), reader)
+	case uri.Hash():
+		w.Header().Set("Content-Type", "text/plain")
+		w.WriteHeader(http.StatusOK)
+		fmt.Fprint(w, addr)
+	}
+
+}
+
+// HandleGetList handles a GET request to bzz-list:/<manifest>/<path> and returns
+// a list of all files contained in <manifest> under <path> grouped into
+// common prefixes using "/" as a delimiter
+func (s *Server) HandleGetList(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	_, credentials, _ := r.BasicAuth()
+	log.Debug("handle.get.list", "ruid", ruid, "uri", uri)
+	getListCount.Inc(1)
+
+	// ensure the root path has a trailing slash so that relative URLs work
+	if uri.Path == "" && !strings.HasSuffix(r.URL.Path, "/") {
+		http.Redirect(w, r, r.URL.Path+"/", http.StatusMovedPermanently)
+		return
+	}
+
+	addr, err := s.api.Resolve(r.Context(), uri.Addr)
+	if err != nil {
+		getListFail.Inc(1)
+		respondError(w, r, fmt.Sprintf("cannot resolve %s: %s", uri.Addr, err), http.StatusNotFound)
+		return
+	}
+	log.Debug("handle.get.list: resolved", "ruid", ruid, "key", addr)
+
+	list, err := s.api.GetManifestList(r.Context(), s.api.Decryptor(r.Context(), credentials), addr, uri.Path)
+	if err != nil {
+		getListFail.Inc(1)
+		if isDecryptError(err) {
+			w.Header().Set("WWW-Authenticate", fmt.Sprintf("Basic realm=%q", addr.String()))
+			respondError(w, r, err.Error(), http.StatusUnauthorized)
+			return
+		}
+		respondError(w, r, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// if the client wants HTML (e.g. a browser) then render the list as a
+	// HTML index with relative URLs
+	if strings.Contains(r.Header.Get("Accept"), "text/html") {
+		w.Header().Set("Content-Type", "text/html")
+		err := TemplatesMap["bzz-list"].Execute(w, &htmlListData{
+			URI: &api.URI{
+				Scheme: "bzz",
+				Addr:   uri.Addr,
+				Path:   uri.Path,
+			},
+			List: &list,
+		})
+		if err != nil {
+			getListFail.Inc(1)
+			log.Error(fmt.Sprintf("error rendering list HTML: %s", err))
+		}
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(&list)
+}
+
+// HandleGetFile handles a GET request to bzz://<manifest>/<path> and responds
+// with the content of the file at <path> from the given <manifest>
+func (s *Server) HandleGetFile(w http.ResponseWriter, r *http.Request) {
+	ruid := GetRUID(r.Context())
+	uri := GetURI(r.Context())
+	_, credentials, _ := r.BasicAuth()
+	log.Debug("handle.get.file", "ruid", ruid, "uri", r.RequestURI)
+	getFileCount.Inc(1)
+
+	// ensure the root path has a trailing slash so that relative URLs work
+	if uri.Path == "" && !strings.HasSuffix(r.URL.Path, "/") {
+		http.Redirect(w, r, r.URL.Path+"/", http.StatusMovedPermanently)
+		return
+	}
+	var err error
+	manifestAddr := uri.Address()
+
+	if manifestAddr == nil {
+		manifestAddr, err = s.api.Resolve(r.Context(), uri.Addr)
+		if err != nil {
+			getFileFail.Inc(1)
+			respondError(w, r, fmt.Sprintf("cannot resolve %s: %s", uri.Addr, err), http.StatusNotFound)
+			return
+		}
+	} else {
+		w.Header().Set("Cache-Control", "max-age=2147483648, immutable") // url was of type bzz://<hex key>/path, so we are sure it is immutable.
+	}
+
+	log.Debug("handle.get.file: resolved", "ruid", ruid, "key", manifestAddr)
+
+	reader, contentType, status, contentKey, err := s.api.Get(r.Context(), s.api.Decryptor(r.Context(), credentials), manifestAddr, uri.Path)
+
+	etag := common.Bytes2Hex(contentKey)
+	noneMatchEtag := r.Header.Get("If-None-Match")
+	w.Header().Set("ETag", fmt.Sprintf("%q", etag)) // set etag to actual content key.
+	if noneMatchEtag != "" {
+		if bytes.Equal(storage.Address(common.Hex2Bytes(noneMatchEtag)), contentKey) {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+	}
+
+	if err != nil {
+		if isDecryptError(err) {
+			w.Header().Set("WWW-Authenticate", fmt.Sprintf("Basic realm=%q", manifestAddr))
+			respondError(w, r, err.Error(), http.StatusUnauthorized)
+			return
+		}
+
+		switch status {
+		case http.StatusNotFound:
+			getFileNotFound.Inc(1)
+			respondError(w, r, err.Error(), http.StatusNotFound)
+		default:
+			getFileFail.Inc(1)
+			respondError(w, r, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	//the request results in ambiguous files
+	//e.g. /read with readme.md and readinglist.txt available in manifest
+	if status == http.StatusMultipleChoices {
+		list, err := s.api.GetManifestList(r.Context(), s.api.Decryptor(r.Context(), credentials), manifestAddr, uri.Path)
+		if err != nil {
+			getFileFail.Inc(1)
+			if isDecryptError(err) {
+				w.Header().Set("WWW-Authenticate", fmt.Sprintf("Basic realm=%q", manifestAddr))
+				respondError(w, r, err.Error(), http.StatusUnauthorized)
+				return
+			}
+			respondError(w, r, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		log.Debug(fmt.Sprintf("Multiple choices! --> %v", list), "ruid", ruid)
+		//show a nice page links to available entries
+		ShowMultipleChoices(w, r, list)
+		return
+	}
+
+	// check the root chunk exists by retrieving the file's size
+	if _, err := reader.Size(r.Context(), nil); err != nil {
+		getFileNotFound.Inc(1)
+		respondError(w, r, fmt.Sprintf("file not found %s: %s", uri, err), http.StatusNotFound)
+		return
+	}
+
+	if contentType != "" {
+		w.Header().Set("Content-Type", contentType)
+	}
+
+	fileName := uri.Addr
+	if found := path.Base(uri.Path); found != "" && found != "." && found != "/" {
+		fileName = found
+	}
+	w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=\"%s\"", fileName))
+
+	http.ServeContent(w, r, fileName, time.Now(), newBufferedReadSeeker(reader, getFileBufferSize))
+}
+
+// calculateNumberOfChunks calculates the number of chunks in an arbitrary content length
+func calculateNumberOfChunks(contentLength int64, isEncrypted bool) int64 {
+	if contentLength < 4096 {
+		return 1
+	}
+	branchingFactor := 128
+	if isEncrypted {
+		branchingFactor = 64
+	}
+
+	dataChunks := math.Ceil(float64(contentLength) / float64(4096))
+	totalChunks := dataChunks
+	intermediate := dataChunks / float64(branchingFactor)
+
+	for intermediate > 1 {
+		totalChunks += math.Ceil(intermediate)
+		intermediate = intermediate / float64(branchingFactor)
+	}
+
+	return int64(totalChunks) + 1
+}
+
+// The size of buffer used for bufio.Reader on LazyChunkReader passed to
+// http.ServeContent in HandleGetFile.
+// Warning: This value influences the number of chunk requests and chunker join goroutines
+// per file request.
+// Recommended value is 4 times the io.Copy default buffer value which is 32kB.
+const getFileBufferSize = 4 * 32 * 1024
+
+// bufferedReadSeeker wraps bufio.Reader to expose Seek method
+// from the provied io.ReadSeeker in newBufferedReadSeeker.
+type bufferedReadSeeker struct {
+	r io.Reader
+	s io.Seeker
+}
+
+// newBufferedReadSeeker creates a new instance of bufferedReadSeeker,
+// out of io.ReadSeeker. Argument `size` is the size of the read buffer.
+func newBufferedReadSeeker(readSeeker io.ReadSeeker, size int) bufferedReadSeeker {
+	return bufferedReadSeeker{
+		r: bufio.NewReaderSize(readSeeker, size),
+		s: readSeeker,
+	}
+}
+
+func (b bufferedReadSeeker) Read(p []byte) (n int, err error) {
+	return b.r.Read(p)
+}
+
+func (b bufferedReadSeeker) Seek(offset int64, whence int) (int64, error) {
+	return b.s.Seek(offset, whence)
+}
+
+type loggingResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
+	return &loggingResponseWriter{w, http.StatusOK}
+}
+
+func (lrw *loggingResponseWriter) WriteHeader(code int) {
+	lrw.statusCode = code
+	lrw.ResponseWriter.WriteHeader(code)
+}
+
+func isDecryptError(err error) bool {
+	return strings.Contains(err.Error(), api.ErrDecrypt.Error())
+}
--- a/api/http/server_test.go
+++ b/api/http/server_test.go
--- a/api/http/templates.go
+++ b/api/http/templates.go
--- a/api/http/test_server.go
+++ b/api/http/test_server.go
@ -0,0 +1,100 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package http
+
+import (
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+
+	"github.com/ethersphere/swarm/api"
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/storage"
+	"github.com/ethersphere/swarm/storage/feed"
+	"github.com/ethersphere/swarm/storage/localstore"
+)
+
+type TestServer interface {
+	ServeHTTP(http.ResponseWriter, *http.Request)
+}
+
+func NewTestSwarmServer(t *testing.T, serverFunc func(*api.API) TestServer, resolver api.Resolver) *TestSwarmServer {
+	swarmDir, err := ioutil.TempDir("", "swarm-storage-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	localStore, err := localstore.New(swarmDir, make([]byte, 32), nil)
+	if err != nil {
+		os.RemoveAll(swarmDir)
+		t.Fatal(err)
+	}
+
+	tags := chunk.NewTags()
+	fileStore := storage.NewFileStore(localStore, storage.NewFileStoreParams(), tags)
+
+	// Swarm feeds test setup
+	feedsDir, err := ioutil.TempDir("", "swarm-feeds-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	feeds, err := feed.NewTestHandler(feedsDir, &feed.HandlerParams{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	swarmApi := api.NewAPI(fileStore, resolver, feeds.Handler, nil, tags)
+	apiServer := httptest.NewServer(serverFunc(swarmApi))
+
+	tss := &TestSwarmServer{
+		Server:    apiServer,
+		FileStore: fileStore,
+		Tags:      tags,
+		dir:       swarmDir,
+		Hasher:    storage.MakeHashFunc(storage.DefaultHash)(),
+		cleanup: func() {
+			apiServer.Close()
+			fileStore.Close()
+			feeds.Close()
+			os.RemoveAll(swarmDir)
+			os.RemoveAll(feedsDir)
+		},
+		CurrentTime: 42,
+	}
+	feed.TimestampProvider = tss
+	return tss
+}
+
+type TestSwarmServer struct {
+	*httptest.Server
+	Hasher      storage.SwarmHash
+	FileStore   *storage.FileStore
+	Tags        *chunk.Tags
+	dir         string
+	cleanup     func()
+	CurrentTime uint64
+}
+
+func (t *TestSwarmServer) Close() {
+	t.cleanup()
+}
+
+func (t *TestSwarmServer) Now() feed.Timestamp {
+	return feed.Timestamp{Time: t.CurrentTime}
+}
--- a/api/inspector.go
+++ b/api/inspector.go
@ -0,0 +1,98 @@
+// Copyright 2019 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/ethereum/go-ethereum/metrics"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/network"
+	"github.com/ethersphere/swarm/storage"
+)
+
+type Inspector struct {
+	api      *API
+	hive     *network.Hive
+	netStore *storage.NetStore
+}
+
+func NewInspector(api *API, hive *network.Hive, netStore *storage.NetStore) *Inspector {
+	return &Inspector{api, hive, netStore}
+}
+
+// Hive prints the kademlia table
+func (i *Inspector) Hive() string {
+	return i.hive.String()
+}
+
+// KademliaInfo returns structured output of the Kademlia state that we can check for equality
+func (i *Inspector) KademliaInfo() network.KademliaInfo {
+	return i.hive.KademliaInfo()
+}
+
+func (i *Inspector) IsPullSyncing() bool {
+	lastReceivedChunksMsg := metrics.GetOrRegisterGauge("network.stream.received_chunks", nil)
+
+	// last received chunks msg time
+	lrct := time.Unix(0, lastReceivedChunksMsg.Value())
+
+	// if last received chunks msg time is after now-15sec. (i.e. within the last 15sec.) then we say that the node is still syncing
+	// technically this is not correct, because this might have been a retrieve request, but for the time being it works for our purposes
+	// because we know we are not making retrieve requests on the node while checking this
+	return lrct.After(time.Now().Add(-15 * time.Second))
+}
+
+// DeliveriesPerPeer returns the sum of chunks we received from a given peer
+func (i *Inspector) DeliveriesPerPeer() map[string]int64 {
+	res := map[string]int64{}
+
+	// iterate connection in kademlia
+	i.hive.Kademlia.EachConn(nil, 255, func(p *network.Peer, po int) bool {
+		// get how many chunks we receive for retrieve requests per peer
+		peermetric := fmt.Sprintf("chunk.delivery.%x", p.Over()[:16])
+
+		res[fmt.Sprintf("%x", p.Over()[:16])] = metrics.GetOrRegisterCounter(peermetric, nil).Count()
+
+		return true
+	})
+
+	return res
+}
+
+// Has checks whether each chunk address is present in the underlying datastore,
+// the bool in the returned structs indicates if the underlying datastore has
+// the chunk stored with the given address (true), or not (false)
+func (i *Inspector) Has(chunkAddresses []storage.Address) string {
+	hostChunks := []string{}
+	for _, addr := range chunkAddresses {
+		has, err := i.netStore.Has(context.Background(), addr)
+		if err != nil {
+			log.Error(err.Error())
+		}
+		if has {
+			hostChunks = append(hostChunks, "1")
+		} else {
+			hostChunks = append(hostChunks, "0")
+		}
+	}
+
+	return strings.Join(hostChunks, "")
+}
--- a/api/manifest.go
+++ b/api/manifest.go
@ -0,0 +1,584 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/ethersphere/swarm/storage/feed"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/storage"
+)
+
+const (
+	ManifestType    = "application/bzz-manifest+json"
+	FeedContentType = "application/bzz-feed"
+
+	manifestSizeLimit = 5 * 1024 * 1024
+)
+
+// Manifest represents a swarm manifest
+type Manifest struct {
+	Entries []ManifestEntry `json:"entries,omitempty"`
+}
+
+// ManifestEntry represents an entry in a swarm manifest
+type ManifestEntry struct {
+	Hash        string       `json:"hash,omitempty"`
+	Path        string       `json:"path,omitempty"`
+	ContentType string       `json:"contentType,omitempty"`
+	Mode        int64        `json:"mode,omitempty"`
+	Size        int64        `json:"size,omitempty"`
+	ModTime     time.Time    `json:"mod_time,omitempty"`
+	Status      int          `json:"status,omitempty"`
+	Access      *AccessEntry `json:"access,omitempty"`
+	Feed        *feed.Feed   `json:"feed,omitempty"`
+}
+
+// ManifestList represents the result of listing files in a manifest
+type ManifestList struct {
+	CommonPrefixes []string         `json:"common_prefixes,omitempty"`
+	Entries        []*ManifestEntry `json:"entries,omitempty"`
+}
+
+// NewManifest creates and stores a new, empty manifest
+func (a *API) NewManifest(ctx context.Context, toEncrypt bool) (storage.Address, error) {
+	var manifest Manifest
+	data, err := json.Marshal(&manifest)
+	if err != nil {
+		return nil, err
+	}
+	addr, wait, err := a.Store(ctx, bytes.NewReader(data), int64(len(data)), toEncrypt)
+	if err != nil {
+		return nil, err
+	}
+	err = wait(ctx)
+	return addr, err
+}
+
+// Manifest hack for supporting Swarm feeds from the bzz: scheme
+// see swarm/api/api.go:API.Get() for more information
+func (a *API) NewFeedManifest(ctx context.Context, feed *feed.Feed) (storage.Address, error) {
+	var manifest Manifest
+	entry := ManifestEntry{
+		Feed:        feed,
+		ContentType: FeedContentType,
+	}
+	manifest.Entries = append(manifest.Entries, entry)
+	data, err := json.Marshal(&manifest)
+	if err != nil {
+		return nil, err
+	}
+	addr, wait, err := a.Store(ctx, bytes.NewReader(data), int64(len(data)), false)
+	if err != nil {
+		return nil, err
+	}
+	err = wait(ctx)
+	return addr, err
+}
+
+// ManifestWriter is used to add and remove entries from an underlying manifest
+type ManifestWriter struct {
+	api   *API
+	trie  *manifestTrie
+	quitC chan bool
+}
+
+func (a *API) NewManifestWriter(ctx context.Context, addr storage.Address, quitC chan bool) (*ManifestWriter, error) {
+	trie, err := loadManifest(ctx, a.fileStore, addr, quitC, NOOPDecrypt)
+	if err != nil {
+		return nil, fmt.Errorf("error loading manifest %s: %s", addr, err)
+	}
+	return &ManifestWriter{a, trie, quitC}, nil
+}
+
+// AddEntry stores the given data and adds the resulting address to the manifest
+func (m *ManifestWriter) AddEntry(ctx context.Context, data io.Reader, e *ManifestEntry) (addr storage.Address, err error) {
+	entry := newManifestTrieEntry(e, nil)
+	if data != nil {
+		var wait func(context.Context) error
+		addr, wait, err = m.api.Store(ctx, data, e.Size, m.trie.encrypted)
+		if err != nil {
+			return nil, err
+		}
+		err = wait(ctx)
+		if err != nil {
+			return nil, err
+		}
+		entry.Hash = addr.Hex()
+	}
+	if entry.Hash == "" {
+		return addr, errors.New("missing entry hash")
+	}
+	m.trie.addEntry(entry, m.quitC)
+	return addr, nil
+}
+
+// RemoveEntry removes the given path from the manifest
+func (m *ManifestWriter) RemoveEntry(path string) error {
+	m.trie.deleteEntry(path, m.quitC)
+	return nil
+}
+
+// Store stores the manifest, returning the resulting storage address
+func (m *ManifestWriter) Store() (storage.Address, error) {
+	return m.trie.ref, m.trie.recalcAndStore()
+}
+
+// ManifestWalker is used to recursively walk the entries in the manifest and
+// all of its submanifests
+type ManifestWalker struct {
+	api   *API
+	trie  *manifestTrie
+	quitC chan bool
+}
+
+func (a *API) NewManifestWalker(ctx context.Context, addr storage.Address, decrypt DecryptFunc, quitC chan bool) (*ManifestWalker, error) {
+	trie, err := loadManifest(ctx, a.fileStore, addr, quitC, decrypt)
+	if err != nil {
+		return nil, fmt.Errorf("error loading manifest %s: %s", addr, err)
+	}
+	return &ManifestWalker{a, trie, quitC}, nil
+}
+
+// ErrSkipManifest is used as a return value from WalkFn to indicate that the
+// manifest should be skipped
+var ErrSkipManifest = errors.New("skip this manifest")
+
+// WalkFn is the type of function called for each entry visited by a recursive
+// manifest walk
+type WalkFn func(entry *ManifestEntry) error
+
+// Walk recursively walks the manifest calling walkFn for each entry in the
+// manifest, including submanifests
+func (m *ManifestWalker) Walk(walkFn WalkFn) error {
+	return m.walk(m.trie, "", walkFn)
+}
+
+func (m *ManifestWalker) walk(trie *manifestTrie, prefix string, walkFn WalkFn) error {
+	for _, entry := range &trie.entries {
+		if entry == nil {
+			continue
+		}
+		entry.Path = prefix + entry.Path
+		err := walkFn(&entry.ManifestEntry)
+		if err != nil {
+			if entry.ContentType == ManifestType && err == ErrSkipManifest {
+				continue
+			}
+			return err
+		}
+		if entry.ContentType != ManifestType {
+			continue
+		}
+		if err := trie.loadSubTrie(entry, nil); err != nil {
+			return err
+		}
+		if err := m.walk(entry.subtrie, entry.Path, walkFn); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type manifestTrie struct {
+	fileStore *storage.FileStore
+	entries   [257]*manifestTrieEntry // indexed by first character of basePath, entries[256] is the empty basePath entry
+	ref       storage.Address         // if ref != nil, it is stored
+	encrypted bool
+	decrypt   DecryptFunc
+}
+
+func newManifestTrieEntry(entry *ManifestEntry, subtrie *manifestTrie) *manifestTrieEntry {
+	return &manifestTrieEntry{
+		ManifestEntry: *entry,
+		subtrie:       subtrie,
+	}
+}
+
+type manifestTrieEntry struct {
+	ManifestEntry
+
+	subtrie *manifestTrie
+}
+
+func loadManifest(ctx context.Context, fileStore *storage.FileStore, addr storage.Address, quitC chan bool, decrypt DecryptFunc) (trie *manifestTrie, err error) { // non-recursive, subtrees are downloaded on-demand
+	log.Trace("manifest lookup", "addr", addr)
+	// retrieve manifest via FileStore
+	manifestReader, isEncrypted := fileStore.Retrieve(ctx, addr)
+	log.Trace("reader retrieved", "addr", addr)
+	return readManifest(manifestReader, addr, fileStore, isEncrypted, quitC, decrypt)
+}
+
+func readManifest(mr storage.LazySectionReader, addr storage.Address, fileStore *storage.FileStore, isEncrypted bool, quitC chan bool, decrypt DecryptFunc) (trie *manifestTrie, err error) { // non-recursive, subtrees are downloaded on-demand
+	// TODO check size for oversized manifests
+	size, err := mr.Size(mr.Context(), quitC)
+	if err != nil { // size == 0
+		// can't determine size means we don't have the root chunk
+		log.Trace("manifest not found", "addr", addr)
+		err = fmt.Errorf("Manifest not Found")
+		return
+	}
+	if size > manifestSizeLimit {
+		log.Warn("manifest exceeds size limit", "addr", addr, "size", size, "limit", manifestSizeLimit)
+		err = fmt.Errorf("Manifest size of %v bytes exceeds the %v byte limit", size, manifestSizeLimit)
+		return
+	}
+	manifestData := make([]byte, size)
+	read, err := mr.Read(manifestData)
+	if int64(read) < size {
+		log.Trace("manifest not found", "addr", addr)
+		if err == nil {
+			err = fmt.Errorf("Manifest retrieval cut short: read %v, expect %v", read, size)
+		}
+		return
+	}
+
+	log.Debug("manifest retrieved", "addr", addr)
+	var man struct {
+		Entries []*manifestTrieEntry `json:"entries"`
+	}
+	err = json.Unmarshal(manifestData, &man)
+	if err != nil {
+		err = fmt.Errorf("Manifest %v is malformed: %v", addr.Log(), err)
+		log.Trace("malformed manifest", "addr", addr)
+		return
+	}
+
+	log.Trace("manifest entries", "addr", addr, "len", len(man.Entries))
+
+	trie = &manifestTrie{
+		fileStore: fileStore,
+		encrypted: isEncrypted,
+		decrypt:   decrypt,
+	}
+	for _, entry := range man.Entries {
+		err = trie.addEntry(entry, quitC)
+		if err != nil {
+			return
+		}
+	}
+	return
+}
+
+func (mt *manifestTrie) addEntry(entry *manifestTrieEntry, quitC chan bool) error {
+	mt.ref = nil // trie modified, hash needs to be re-calculated on demand
+
+	if entry.ManifestEntry.Access != nil {
+		if mt.decrypt == nil {
+			return errors.New("dont have decryptor")
+		}
+
+		err := mt.decrypt(&entry.ManifestEntry)
+		if err != nil {
+			return err
+		}
+	}
+
+	if len(entry.Path) == 0 {
+		mt.entries[256] = entry
+		return nil
+	}
+
+	b := entry.Path[0]
+	oldentry := mt.entries[b]
+	if (oldentry == nil) || (oldentry.Path == entry.Path && oldentry.ContentType != ManifestType) {
+		mt.entries[b] = entry
+		return nil
+	}
+
+	cpl := 0
+	for (len(entry.Path) > cpl) && (len(oldentry.Path) > cpl) && (entry.Path[cpl] == oldentry.Path[cpl]) {
+		cpl++
+	}
+
+	if (oldentry.ContentType == ManifestType) && (cpl == len(oldentry.Path)) {
+		if mt.loadSubTrie(oldentry, quitC) != nil {
+			return nil
+		}
+		entry.Path = entry.Path[cpl:]
+		oldentry.subtrie.addEntry(entry, quitC)
+		oldentry.Hash = ""
+		return nil
+	}
+
+	commonPrefix := entry.Path[:cpl]
+
+	subtrie := &manifestTrie{
+		fileStore: mt.fileStore,
+		encrypted: mt.encrypted,
+	}
+	entry.Path = entry.Path[cpl:]
+	oldentry.Path = oldentry.Path[cpl:]
+	subtrie.addEntry(entry, quitC)
+	subtrie.addEntry(oldentry, quitC)
+
+	mt.entries[b] = newManifestTrieEntry(&ManifestEntry{
+		Path:        commonPrefix,
+		ContentType: ManifestType,
+	}, subtrie)
+	return nil
+}
+
+func (mt *manifestTrie) getCountLast() (cnt int, entry *manifestTrieEntry) {
+	for _, e := range &mt.entries {
+		if e != nil {
+			cnt++
+			entry = e
+		}
+	}
+	return
+}
+
+func (mt *manifestTrie) deleteEntry(path string, quitC chan bool) {
+	mt.ref = nil // trie modified, hash needs to be re-calculated on demand
+
+	if len(path) == 0 {
+		mt.entries[256] = nil
+		return
+	}
+
+	b := path[0]
+	entry := mt.entries[b]
+	if entry == nil {
+		return
+	}
+	if entry.Path == path {
+		mt.entries[b] = nil
+		return
+	}
+
+	epl := len(entry.Path)
+	if (entry.ContentType == ManifestType) && (len(path) >= epl) && (path[:epl] == entry.Path) {
+		if mt.loadSubTrie(entry, quitC) != nil {
+			return
+		}
+		entry.subtrie.deleteEntry(path[epl:], quitC)
+		entry.Hash = ""
+		// remove subtree if it has less than 2 elements
+		cnt, lastentry := entry.subtrie.getCountLast()
+		if cnt < 2 {
+			if lastentry != nil {
+				lastentry.Path = entry.Path + lastentry.Path
+			}
+			mt.entries[b] = lastentry
+		}
+	}
+}
+
+func (mt *manifestTrie) recalcAndStore() error {
+	if mt.ref != nil {
+		return nil
+	}
+
+	var buffer bytes.Buffer
+	buffer.WriteString(`{"entries":[`)
+
+	list := &Manifest{}
+	for _, entry := range &mt.entries {
+		if entry != nil {
+			if entry.Hash == "" { // TODO: paralellize
+				err := entry.subtrie.recalcAndStore()
+				if err != nil {
+					return err
+				}
+				entry.Hash = entry.subtrie.ref.Hex()
+			}
+			list.Entries = append(list.Entries, entry.ManifestEntry)
+		}
+
+	}
+
+	manifest, err := json.Marshal(list)
+	if err != nil {
+		return err
+	}
+
+	sr := bytes.NewReader(manifest)
+	ctx := context.TODO()
+	addr, wait, err2 := mt.fileStore.Store(ctx, sr, int64(len(manifest)), mt.encrypted)
+	if err2 != nil {
+		return err2
+	}
+	err2 = wait(ctx)
+	mt.ref = addr
+	return err2
+}
+
+func (mt *manifestTrie) loadSubTrie(entry *manifestTrieEntry, quitC chan bool) (err error) {
+	if entry.ManifestEntry.Access != nil {
+		if mt.decrypt == nil {
+			return errors.New("dont have decryptor")
+		}
+
+		err := mt.decrypt(&entry.ManifestEntry)
+		if err != nil {
+			return err
+		}
+	}
+
+	if entry.subtrie == nil {
+		hash := common.Hex2Bytes(entry.Hash)
+		entry.subtrie, err = loadManifest(context.TODO(), mt.fileStore, hash, quitC, mt.decrypt)
+		entry.Hash = "" // might not match, should be recalculated
+	}
+	return
+}
+
+func (mt *manifestTrie) listWithPrefixInt(prefix, rp string, quitC chan bool, cb func(entry *manifestTrieEntry, suffix string)) error {
+	plen := len(prefix)
+	var start, stop int
+	if plen == 0 {
+		start = 0
+		stop = 256
+	} else {
+		start = int(prefix[0])
+		stop = start
+	}
+
+	for i := start; i <= stop; i++ {
+		select {
+		case <-quitC:
+			return fmt.Errorf("aborted")
+		default:
+		}
+		entry := mt.entries[i]
+		if entry != nil {
+			epl := len(entry.Path)
+			if entry.ContentType == ManifestType {
+				l := plen
+				if epl < l {
+					l = epl
+				}
+				if prefix[:l] == entry.Path[:l] {
+					err := mt.loadSubTrie(entry, quitC)
+					if err != nil {
+						return err
+					}
+					err = entry.subtrie.listWithPrefixInt(prefix[l:], rp+entry.Path[l:], quitC, cb)
+					if err != nil {
+						return err
+					}
+				}
+			} else {
+				if (epl >= plen) && (prefix == entry.Path[:plen]) {
+					cb(entry, rp+entry.Path[plen:])
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (mt *manifestTrie) listWithPrefix(prefix string, quitC chan bool, cb func(entry *manifestTrieEntry, suffix string)) (err error) {
+	return mt.listWithPrefixInt(prefix, "", quitC, cb)
+}
+
+func (mt *manifestTrie) findPrefixOf(path string, quitC chan bool) (entry *manifestTrieEntry, pos int) {
+	log.Trace(fmt.Sprintf("findPrefixOf(%s)", path))
+
+	if len(path) == 0 {
+		return mt.entries[256], 0
+	}
+
+	//see if first char is in manifest entries
+	b := path[0]
+	entry = mt.entries[b]
+	if entry == nil {
+		return mt.entries[256], 0
+	}
+
+	epl := len(entry.Path)
+	log.Trace(fmt.Sprintf("path = %v  entry.Path = %v  epl = %v", path, entry.Path, epl))
+	if len(path) <= epl {
+		if entry.Path[:len(path)] == path {
+			if entry.ContentType == ManifestType {
+				err := mt.loadSubTrie(entry, quitC)
+				if err == nil && entry.subtrie != nil {
+					subentries := entry.subtrie.entries
+					for i := 0; i < len(subentries); i++ {
+						sub := subentries[i]
+						if sub != nil && sub.Path == "" {
+							return sub, len(path)
+						}
+					}
+				}
+				entry.Status = http.StatusMultipleChoices
+			}
+			pos = len(path)
+			return
+		}
+		return nil, 0
+	}
+	if path[:epl] == entry.Path {
+		log.Trace(fmt.Sprintf("entry.ContentType = %v", entry.ContentType))
+		//the subentry is a manifest, load subtrie
+		if entry.ContentType == ManifestType && (strings.Contains(entry.Path, path) || strings.Contains(path, entry.Path)) {
+			err := mt.loadSubTrie(entry, quitC)
+			if err != nil {
+				return nil, 0
+			}
+			sub, pos := entry.subtrie.findPrefixOf(path[epl:], quitC)
+			if sub != nil {
+				entry = sub
+				pos += epl
+				return sub, pos
+			} else if path == entry.Path {
+				entry.Status = http.StatusMultipleChoices
+			}
+
+		} else {
+			//entry is not a manifest, return it
+			if path != entry.Path {
+				return nil, 0
+			}
+		}
+	}
+	return nil, 0
+}
+
+// file system manifest always contains regularized paths
+// no leading or trailing slashes, only single slashes inside
+func RegularSlashes(path string) (res string) {
+	for i := 0; i < len(path); i++ {
+		if (path[i] != '/') || ((i > 0) && (path[i-1] != '/')) {
+			res = res + path[i:i+1]
+		}
+	}
+	if (len(res) > 0) && (res[len(res)-1] == '/') {
+		res = res[:len(res)-1]
+	}
+	return
+}
+
+func (mt *manifestTrie) getEntry(spath string) (entry *manifestTrieEntry, fullpath string) {
+	path := RegularSlashes(spath)
+	var pos int
+	quitC := make(chan bool)
+	entry, pos = mt.findPrefixOf(path, quitC)
+	return entry, path[:pos]
+}
--- a/api/manifest_test.go
+++ b/api/manifest_test.go
@ -0,0 +1,176 @@
+// Copyright 2016 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/ethersphere/swarm/chunk"
+	"github.com/ethersphere/swarm/storage"
+)
+
+func manifest(paths ...string) (manifestReader storage.LazySectionReader) {
+	var entries []string
+	for _, path := range paths {
+		entry := fmt.Sprintf(`{"path":"%s"}`, path)
+		entries = append(entries, entry)
+	}
+	manifest := fmt.Sprintf(`{"entries":[%s]}`, strings.Join(entries, ","))
+	return &storage.LazyTestSectionReader{
+		SectionReader: io.NewSectionReader(strings.NewReader(manifest), 0, int64(len(manifest))),
+	}
+}
+
+func testGetEntry(t *testing.T, path, match string, multiple bool, paths ...string) *manifestTrie {
+	quitC := make(chan bool)
+	fileStore := storage.NewFileStore(nil, storage.NewFileStoreParams(), chunk.NewTags())
+	ref := make([]byte, fileStore.HashSize())
+	trie, err := readManifest(manifest(paths...), ref, fileStore, false, quitC, NOOPDecrypt)
+	if err != nil {
+		t.Errorf("unexpected error making manifest: %v", err)
+	}
+	checkEntry(t, path, match, multiple, trie)
+	return trie
+}
+
+func checkEntry(t *testing.T, path, match string, multiple bool, trie *manifestTrie) {
+	entry, fullpath := trie.getEntry(path)
+	if match == "-" && entry != nil {
+		t.Errorf("expected no match for '%s', got '%s'", path, fullpath)
+	} else if entry == nil {
+		if match != "-" {
+			t.Errorf("expected entry '%s' to match '%s', got no match", match, path)
+		}
+	} else if fullpath != match {
+		t.Errorf("incorrect entry retrieved for '%s'. expected path '%v', got '%s'", path, match, fullpath)
+	}
+
+	if multiple && entry.Status != http.StatusMultipleChoices {
+		t.Errorf("Expected %d Multiple Choices Status for path %s, match %s, got %d", http.StatusMultipleChoices, path, match, entry.Status)
+	} else if !multiple && entry != nil && entry.Status == http.StatusMultipleChoices {
+		t.Errorf("Were not expecting %d Multiple Choices Status for path %s, match %s, but got it", http.StatusMultipleChoices, path, match)
+	}
+}
+
+func TestGetEntry(t *testing.T) {
+	// file system manifest always contains regularized paths
+	testGetEntry(t, "a", "a", false, "a")
+	testGetEntry(t, "b", "-", false, "a")
+	testGetEntry(t, "/a//", "a", false, "a")
+	// fallback
+	testGetEntry(t, "/a", "", false, "")
+	testGetEntry(t, "/a/b", "a/b", false, "a/b")
+	// longest/deepest math
+	testGetEntry(t, "read", "read", true, "readme.md", "readit.md")
+	testGetEntry(t, "rf", "-", false, "readme.md", "readit.md")
+	testGetEntry(t, "readme", "readme", false, "readme.md")
+	testGetEntry(t, "readme", "-", false, "readit.md")
+	testGetEntry(t, "readme.md", "readme.md", false, "readme.md")
+	testGetEntry(t, "readme.md", "-", false, "readit.md")
+	testGetEntry(t, "readmeAmd", "-", false, "readit.md")
+	testGetEntry(t, "readme.mdffff", "-", false, "readme.md")
+	testGetEntry(t, "ab", "ab", true, "ab/cefg", "ab/cedh", "ab/kkkkkk")
+	testGetEntry(t, "ab/ce", "ab/ce", true, "ab/cefg", "ab/cedh", "ab/ceuuuuuuuuuu")
+	testGetEntry(t, "abc", "abc", true, "abcd", "abczzzzef", "abc/def", "abc/e/g")
+	testGetEntry(t, "a/b", "a/b", true, "a", "a/bc", "a/ba", "a/b/c")
+	testGetEntry(t, "a/b", "a/b", false, "a", "a/b", "a/bb", "a/b/c")
+	testGetEntry(t, "//a//b//", "a/b", false, "a", "a/b", "a/bb", "a/b/c")
+}
+
+func TestExactMatch(t *testing.T) {
+	quitC := make(chan bool)
+	mf := manifest("shouldBeExactMatch.css", "shouldBeExactMatch.css.map")
+	fileStore := storage.NewFileStore(nil, storage.NewFileStoreParams(), chunk.NewTags())
+	ref := make([]byte, fileStore.HashSize())
+	trie, err := readManifest(mf, ref, fileStore, false, quitC, nil)
+	if err != nil {
+		t.Errorf("unexpected error making manifest: %v", err)
+	}
+	entry, _ := trie.getEntry("shouldBeExactMatch.css")
+	if entry.Path != "" {
+		t.Errorf("Expected entry to match %s, got: %s", "shouldBeExactMatch.css", entry.Path)
+	}
+	if entry.Status == http.StatusMultipleChoices {
+		t.Errorf("Got status %d, which is unexepcted", http.StatusMultipleChoices)
+	}
+}
+
+func TestDeleteEntry(t *testing.T) {
+
+}
+
+// TestAddFileWithManifestPath tests that adding an entry at a path which
+// already exists as a manifest just adds the entry to the manifest rather
+// than replacing the manifest with the entry
+func TestAddFileWithManifestPath(t *testing.T) {
+	// create a manifest containing "ab" and "ac"
+	manifest, _ := json.Marshal(&Manifest{
+		Entries: []ManifestEntry{
+			{Path: "ab", Hash: "ab"},
+			{Path: "ac", Hash: "ac"},
+		},
+	})
+	reader := &storage.LazyTestSectionReader{
+		SectionReader: io.NewSectionReader(bytes.NewReader(manifest), 0, int64(len(manifest))),
+	}
+	fileStore := storage.NewFileStore(nil, storage.NewFileStoreParams(), chunk.NewTags())
+	ref := make([]byte, fileStore.HashSize())
+	trie, err := readManifest(reader, ref, fileStore, false, nil, NOOPDecrypt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	checkEntry(t, "ab", "ab", false, trie)
+	checkEntry(t, "ac", "ac", false, trie)
+
+	// now add path "a" and check we can still get "ab" and "ac"
+	entry := &manifestTrieEntry{}
+	entry.Path = "a"
+	entry.Hash = "a"
+	trie.addEntry(entry, nil)
+	checkEntry(t, "ab", "ab", false, trie)
+	checkEntry(t, "ac", "ac", false, trie)
+	checkEntry(t, "a", "a", false, trie)
+}
+
+// TestReadManifestOverSizeLimit creates a manifest reader with data longer then
+// manifestSizeLimit and checks if readManifest function will return the exact error
+// message.
+// The manifest data is not in json-encoded format, preventing possbile
+// successful parsing attempts if limit check fails.
+func TestReadManifestOverSizeLimit(t *testing.T) {
+	manifest := make([]byte, manifestSizeLimit+1)
+	reader := &storage.LazyTestSectionReader{
+		SectionReader: io.NewSectionReader(bytes.NewReader(manifest), 0, int64(len(manifest))),
+	}
+	_, err := readManifest(reader, storage.Address{}, nil, false, nil, NOOPDecrypt)
+	if err == nil {
+		t.Fatal("got no error from readManifest")
+	}
+	// Error message is part of the http response body
+	// which justifies exact string validation.
+	got := err.Error()
+	want := fmt.Sprintf("Manifest size of %v bytes exceeds the %v byte limit", len(manifest), manifestSizeLimit)
+	if got != want {
+		t.Fatalf("got error mesage %q, expected %q", got, want)
+	}
+}
--- a/api/testdata/test0/img/logo.png
+++ b/api/testdata/test0/img/logo.png
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Rafael Matias	66e016c6dc	swarm: release v0.4.3 (#1602 ) * swarm: 0.4.3 release notes * swarm: 0.4.3 stable version * swarm: 0.4.3 release notes - fix	2019-07-25 13:08:29 +02:00
acud	74b12e35bf	network/retrieve: add bzz-retrieve protocol (#1589 ) * network/retrieve: initial commit * network: import dependencies from stream package branch * network/retrieve: address pr comments * network/retrieve: fix pr comments * network/retrieve: create logger for peer * network: address pr comments * network/retrieve: lint * network/retrieve: prevent forever loop * network/retrieve: address pr comments * network/retrieve: fix linter * network/retrieve: pr comments * network/retrieval: pr comments	2019-07-25 10:53:46 +02:00
Rafael Matias	388d8ccd9f	PoC: Network simulation framework (#1555 ) * simv2: wip * simulation: exec adapter start/stop * simulation: add node status to exec adapter * simulation: initial simulation code * simulation: exec adapter, configure path to executable * simulation: initial docker adapter * simulation: wip kubernetes adapter * simulation: kubernetes adapter proxy * simulation: implement GetAll/StartAll/StopAll * simulation: kuberentes adapter - set env vars and resource limits * simulation: discovery test * simulation: remove port definitions within docker adapter * simulation: simplify wait for healthy loop * simulation: get nat ip addr from interface * simulation: pull docker images automatically * simulation: NodeStatus -> NodeInfo * simulation: move discovery test to example dir * simulation: example snapshot usage * simulation: add goclient specific simulation * simulation: add peer connections to snapshot * simulation: close rpc client * simulation: don't export kubernetes proxy server * simulation: merge simulation code * simulation: don't export nodemap * simulation: rename SimulationSnapshot -> Snapshot * simulation: linting fixes * simulation: add k8s available helper func * simulation: vendor * simulation: fix 'no non-test Go files' when building * simulation: remove errors from interface methods where non were returned * simulation: run getHealthInfo check in parallel	2019-07-24 17:00:13 +02:00
Anton Evangelatov	9720da34db	network: structured output for kademlia table (#1586 )	2019-07-19 13:35:11 +02:00
Anton Evangelatov	090197227f	client: add bzz client, update smoke tests (#1582 )	2019-07-18 18:49:20 +02:00
Anton Evangelatov	48857ae88e	swarm-smoke: fix check max prox hosts for pull/push sync modes (#1578 )	2019-07-17 16:21:50 +02:00
Rafael Matias	ad77f43b9d	cmd/swarm: allow using a network interface by name for nat purposes (#1557 )	2019-07-16 09:35:04 +02:00
Anton Evangelatov	9d96d9bef5	pss: disable TestForwardBasic (#1544 )	2019-07-11 18:17:26 +02:00
Anton Evangelatov	7101f65a8b	api, network: count chunk deliveries per peer (#1534 )	2019-07-09 22:50:06 +02:00
acud	af3b5e9ce1	network/newstream: new stream! protocol base implementation (#1500 ) network/newstream: merge new stream protocol wire protocol changes, changes to docs, add basic protocol handlers and placeholders	2019-07-08 13:25:56 +03:00
Rafael Matias	7deac5693c	swarm: fix bzz_info.port when using dynamic port allocation (#1537 )	2019-07-05 12:15:17 +02:00
Rafael Matias	d5f6ee4620	cmd/swarm: make bzzaccount flag optional and add bzzkeyhex flag (#1531 ) * cmd/swarm: don't require bzzaccount flag * docker: remove setup script because bzzaccount is not required anymore * cmd/swarm: manage account creation/selection when bzzflag is not defined * cmd/swarm: no bzzaccount flag tests * cmd/swarm: use random network ports on tests * cmd/swarm: fix typo * cmd/swarm: add --bzzkeyhex flag * cmd/swarm: use different ipc paths for tests * readme: update example on how to run swarm * cmd/swarm: rename getAccount -> getOrCreateAccount * cmd/swarm: remove unneeded comment * cmd/swarm: use shorter ipc path for test	2019-07-04 13:14:10 +02:00
Rafael Matias	fb73e6cb9b	cmd/swarm: remove separate function to parse env vars (#1536 )	2019-07-04 13:13:39 +02:00
lash	a6e64aea67	network/bitvector: Multibit set/unset + string rep (#1530 ) * network/bitvector: Multibit set/unset + string rep * network/bitvector: Add code comments * network/bitvector: Make Unset -> Set with bool false * network/bitvector: Revert to Set/Unset * network/stream: Update to new bitvector signature	2019-07-02 18:08:00 +02:00
Anton Evangelatov	b3f21ddbba	swarm: 0.4.3 unstable (#1526 ) * swarm: 0.4.3 unstable * CHANGELOG: consistent date format	2019-06-28 12:22:07 +02:00
Rafael Matias	3cdc45ee0f	travis: also build on release tags (#1527 )	2019-06-28 12:02:47 +02:00
Anton Evangelatov	bef511363e	swarm: release v0.4.2 (#1496 ) * CHANGELOG: reflect latest merged PRs * changelog: updated changelog for swarm 0.4.2 * version: mark 0.4.2 stable	2019-06-28 11:19:28 +02:00
Anton Evangelatov	fb75cdce03	network: bump bzz stream hive (#1522 )	2019-06-28 10:21:14 +02:00
Rafael Matias	13774a8aee	docker: update ca-certificates file (#1525 )	2019-06-27 18:06:09 +02:00
Rafael Matias	4d66995fee	Add swarm guide to /docs (#1513 ) * docs: add swarm-guide * readthedocs build configuration file	2019-06-26 10:18:32 +02:00
lash	a0a14cc11c	network/simulation: Add ExecAdapter capability to swarm simulations (#1503 )	2019-06-24 09:48:40 +02:00
acud	8afb316399	docs: add initial stream! protocol specification (#1454 ) * docs: add initial pull sync spec	2019-06-20 12:21:07 +02:00
Rafael Matias	f2a12b38c4	docs: release process setup (#1487 )	2019-06-19 11:12:56 +02:00
Rafael Matias	f828da674d	build: enable ubuntu ppa disco (19.04) builds (#1495 )	2019-06-18 15:34:30 +02:00
Anton Evangelatov	9fa6d29c88	network/stream: remove send.offered.hashes trace (#1497 )	2019-06-18 14:53:18 +02:00
Anton Evangelatov	d589af14a8	simple fetchers (#1492 ) * network: disable shouldNOTRequestAgain * vendor singleflight * network: disable shouldNOTRequestAgain * network, storage: fix tests * network/storage: remove HopCount and SkipCheck * network/stream: use localstore when providing chunks a node has offered * storage: refactor lnetstore * storage: rename FetcherItem to Fetcher * storage/feed: no distinction between catastrophic err or chunk not found * network/stream: remove TestDeliveryFromNodes, as FindPeer is changed, and Swarm connectivity is not a chain * network/stream: fixed intervals tests * swarm: fixes for linter * storage: use LRU cache for fetchers * network, storage: better godoc * storage/netstore: explicit errors * storage/feed/lookup: Clarify ReadFunc expected return error values * storage: address comments by elad	2019-06-18 08:47:27 +02:00
Zahoor Mohamed	f57d4f0802	swarm/storage: Support for uploading 100gb files (#1395 ) * swarm/storage: Fix gouroutine leak while uploading large files * swarm/storage: Fix pyramid chunker to wrap properly level3 and above	2019-06-18 08:46:20 +02:00
Anton Evangelatov	604960938b	Revert "simplification of Fetchers (#1344 )" (#1491 ) This reverts commit `0b724bd4d5`.	2019-06-17 10:30:55 +02:00
Anton Evangelatov	0b724bd4d5	simplification of Fetchers (#1344 )	2019-06-17 10:01:12 +02:00
Rafael Matias	21adbe2fac	docker: include git commit hash in swarm version (#1488 ) * dockerignore: remove .git - needed for git hash on builds * changelog: include #1488	2019-06-14 15:49:18 +02:00
acud	8b37def961	cmd/swarm-smoke: fix what we wanted to avoid (#1486 )	2019-06-14 14:49:21 +02:00
Rafael Matias	fce3e45f2b	build: don't upload buildinfo (#1484 )	2019-06-14 14:24:12 +02:00
Anton Evangelatov	99db027993	docker: fix run-smoke.sh path to binary (#1485 )	2019-06-14 14:22:55 +02:00
Rafael Matias	8a1f6a6c6f	README: add docker section and fix license section (#1483 ) * readme: add docker section * readme: fix license info * readme: omit sections in toc	2019-06-14 12:18:56 +02:00
acud	9704ced894	cmd/swarm-smoke: add paging to trackChunks (#1464 ) * cmd/swarm-smoke: add paging to trackChunks	2019-06-14 10:46:41 +02:00
Rafael Matias	99a431cf50	version: update to v0.4.2 unstable (#1470 )	2019-06-13 17:45:36 +02:00
Rafael Matias	0b9a3ea407	swarm: release v0.4.1 (#1469 )	2019-06-13 16:32:55 +02:00
Anton Evangelatov	2f0b94fa1a	network: bump proto versions due to change in OfferedHashesMsg (#1465 )	2019-06-13 16:11:46 +02:00
Rafael Matias	815a6d120f	changelog: initial setup (#1466 )	2019-06-13 16:04:16 +02:00
Anton Evangelatov	4744b7c9d7	p2p/protocols: do not vendor swarm related packages (#1462 )	2019-06-13 15:11:00 +02:00
Rafael Matias	3243c7ba07	docker: create new dockerfiles that are context aware (#1463 )	2019-06-13 14:30:13 +02:00
Rafael Matias	76e71cca3b	network/stream: disable flaky TestStartNetworkSync test (#1458 )	2019-06-12 15:50:44 +02:00
Rafael Matias	b3f601427c	storage: fix alignement panics on 32 bit arch (#1460 )	2019-06-12 12:55:36 +02:00
Rafael Matias	f709083e47	api: temporary fix test failing on windows due to access denied (#1450 )	2019-06-12 10:00:46 +02:00
Anton Evangelatov	e865445f17	network/stream: remove cast for msg type (#1449 )	2019-06-12 08:55:15 +02:00
Anton Evangelatov	de220b8323	docs: arch diagram - use source of truth images (#1434 )	2019-06-11 10:17:45 +02:00
acud	c1126aaa1b	swarm/network/stream: add syncing test (#1399 ) * swarm/network/stream: remove old syncing test and replace it with two more granular tests, with the first one testing a full sync between two nodes (makes sure that when all subscriptions are established on all bins - all content is replicated from one node to the other), and a second test that adds a bigger amount of nodes to a star network topology, effectively making the pivot node have a depth > 0 to sync just certain content to the connected nodes (due to a star topology this test (always 1 hop) does not check that, for example, specific content is routed across multiple nodes, but assumes content should be only on the most proximate node) * api, cmd/swarm-smoke, fuse, network, storage: fix data dir leak when using ephemeral filestore, pull test params to be easily adjustable	2019-06-10 10:52:19 +02:00
Anton Evangelatov	ee7ccbdb4d	docs: initial swarm arch diagram (#1432 ) Important high-level diagrams added	2019-06-07 13:27:20 +02:00
Anton Evangelatov	bedd06762d	swarm-smoke: add debug flag (#1428 )	2019-06-06 15:06:18 +02:00
Anton Evangelatov	5663cb2c76	docs: push syncing tags doc (#1429 )	2019-06-06 14:51:58 +02:00
acud	a454aa6c8d	swarm,cmd: fix migration link, change loglevel severity (#1420 )	2019-06-06 14:46:28 +02:00
Anton Evangelatov	bd1887189c	swarm/network/stream: remove dead code (#1422 ) * swarm/network/stream: remove dead code * swarm/network/stream: remove HandoverProof	2019-06-05 12:59:46 +02:00
Rafael Matias	6d0902da3c	p2p/protocols: import to codebase, remove from vendor (#1416 )	2019-06-04 14:32:44 +02:00
Aron	70320ceeae	Makefile: added support for "make swarm" command (#1412 )	2019-06-03 20:59:48 +02:00
Rafael Matias	3e522f2e7d	appveyor: remove unused nsis task (#1410 )	2019-06-03 15:33:09 +02:00
Anton Evangelatov	1c8c8bac45	build/deb: fix deb.control for ethereum-swarm (#1414 ) * build/deb: fix deb.control for ethereum-swarm * build: env.sh fix	2019-06-03 15:26:37 +02:00
Rafael Matias	809165fc5e	ci/cd: fix azure blobstorage name (#1413 )	2019-06-03 15:16:56 +02:00
Rafael Matias	2c80a4198f	Appveyor branches: master only (#1409 )	2019-06-03 14:18:41 +02:00
Anton Evangelatov	a83a84460e	.github: fix contributing.md (#1408 )	2019-06-03 14:08:40 +02:00
Anton Evangelatov	c5430df218	README.md: modify installation instructions after repo split (#1407 )	2019-06-03 13:10:20 +02:00
Rafael Matias	b046760db1	swarm: codebase split from go-ethereum (#1405 )	2019-06-03 12:28:18 +02:00
				`@ -1 +0,0 @@`
				`{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}`
				`@ -1 +0,0 @@`
				`{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3}`
				`@ -1 +0,0 @@`
				`{"address":"fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e","crypto":{"cipher":"aes-128-ctr","ciphertext":"8124d5134aa4a927c79fd852989e4b5419397566f04b0936a1eb1d168c7c68a5","cipherparams":{"iv":"e2febe17176414dd2cda28287947eb2f"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":4096,"p":6,"r":8,"salt":"44b415ede89f3bdd6830390a21b78965f571b347a589d1d943029f016c5e8bd5"},"mac":"5e149ff25bfd9dd45746a84bb2bcd2f015f2cbca2b6d25c5de8c29617f71fe5b"},"id":"d6ac5452-2b2c-4d3c-ad80-4bf0327d971c","version":3}`
				`@ -1 +0,0 @@`
				`{"crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}`
				`@ -1 +0,0 @@`
				`{"address":"0000000000000000000000000000000000000000","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3}`
				`@ -1 +0,0 @@`
				`{"address":"289d485d9771714cce91d3393d764e1311907acc","crypto":{"cipher":"aes-128-ctr","ciphertext":"faf32ca89d286b107f5e6d842802e05263c49b78d46eac74e6109e9a963378ab","cipherparams":{"iv":"558833eec4a665a8c55608d7d503407d"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"d571fff447ffb24314f9513f5160246f09997b857ac71348b73e785aab40dc04"},"mac":"21edb85ff7d0dab1767b9bf498f2c3cb7be7609490756bd32300bb213b59effe"},"id":"3279afcf-55ba-43ff-8997-02dcc46a6525","version":3}`
				`@ -1 +0,0 @@`
				{"address":"cb61d5a9c4896fb9658090b597ef0e7be6f7b67e","Crypto":{"cipher":"aes-128-cbc","ciphertext":"6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0","cipherparams":{"iv":"35337770fc2117994ecdcad026bccff4"},"kdf":"scrypt","kdfparams":{"n":262144,"r":8,"p":1,"dklen":32,"salt":"9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"},"mac":"3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644","version":"1"},"id":"e25f7c1f-d318-4f29-b62c-687190d4d299","version":"1"}
				`@ -1 +0,0 @@`
				`{"address":"45dea0fb0bba44f4fcf290bba71fd57d7117cbb8","crypto":{"cipher":"aes-128-ctr","ciphertext":"b87781948a1befd247bff51ef4063f716cf6c2d3481163e9a8f42e1f9bb74145","cipherparams":{"iv":"dc4926b48a105133d2f16b96833abf1e"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":2,"p":1,"r":8,"salt":"004244bbdc51cadda545b1cfa43cff9ed2ae88e08c61f1479dbb45410722f8f0"},"mac":"39990c1684557447940d4c69e06b1b82b2aceacb43f284df65c956daf3046b85"},"id":"ce541d8d-c79b-40f8-9f8c-20f59616faba","version":3}`