Merge pull request #19473 from karalabe/geth-1.8.27

[1.8.27 backport] eth, les, light: enforce CHT checkpoints on fast-sync too

.dockerignore

@@ -1,3 +1,7 @@
+**/.git
+.git
+!.git/HEAD
+!.git/refs/heads
 **/*_test.go
 
 build/_workspace

.github/CODEOWNERS

@@ -2,21 +2,12 @@
 # Each line is a file pattern followed by one or more owners.
 
 accounts/usbwallet              @karalabe
-accounts/scwallet               @gballet
-accounts/abi                    @gballet @MariusVanDerWijden
-cmd/clef                        @holiman
-cmd/puppeth                     @karalabe
+accounts/abi                    @gballet
 consensus                       @karalabe
-core/                           @karalabe @holiman @rjl493456442
-eth/                            @karalabe @holiman @rjl493456442
-graphql/                        @gballet
-les/                            @zsfelfoldi @rjl493456442
-light/                          @zsfelfoldi @rjl493456442
-mobile/                         @karalabe @ligi
-node/                           @fjl @renaynay
+core/                           @karalabe @holiman
+eth/                            @karalabe
+les/                            @zsfelfoldi
+light/                          @zsfelfoldi
+mobile/                         @karalabe
 p2p/                            @fjl @zsfelfoldi
-rpc/                            @fjl @holiman
-p2p/simulations                 @fjl
-p2p/protocols                   @fjl
-p2p/testing                     @fjl
-signer/                         @holiman
+whisper/                        @gballet @gluk256

.github/CONTRIBUTING.md

@@ -30,11 +30,11 @@ Please make sure your contributions adhere to our coding guidelines:
 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 
-[Geth documentation page](https://geth.ethereum.org/docs/) for more info
+[Wiki page](https://github.com/ethereum/go-ethereum/wiki) for more info
 and help.
 
 ## Configuration, dependencies, and tests
 
-Please see the [Developers' Guide](https://geth.ethereum.org/docs/developers/devguide)
+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.

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,26 @@
+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.
+
+#### System information
+
+Geth version: `geth version`
+OS & Version: Windows/Linux/OSX
+Commit hash : (if `develop`)
+
+#### Expected behaviour
+
+
+#### Actual behaviour
+
+
+#### Steps to reproduce the behaviour
+
+
+#### Backtrace
+
+````
+[backtrace]
+````

.github/ISSUE_TEMPLATE/bug.md

@@ -1,28 +0,0 @@
----
-name: Report a bug
-about: Something with go-ethereum is not working as expected
-title: ''
-labels: 'type:bug'
-assignees: ''
----
-
-#### System information
-
-Geth version: `geth version`
-OS & Version: Windows/Linux/OSX
-Commit hash : (if `develop`)
-
-#### Expected behaviour
-
-
-#### Actual behaviour
-
-
-#### Steps to reproduce the behaviour
-
-
-#### Backtrace
-
-````
-[backtrace]
-````

.github/ISSUE_TEMPLATE/feature.md

@@ -1,17 +0,0 @@
----
-name: Request a feature
-about: Report a missing feature - e.g. as a step before submitting a PR
-title: ''
-labels: 'type:feature'
-assignees: ''
----
-
-# Rationale
-
-Why should this feature exist?
-What are the use-cases?
-
-# Implementation
-
-Do you have ideas regarding the implementation of this feature?
-Are you willing to implement this feature?

.github/ISSUE_TEMPLATE/question.md

@@ -1,9 +0,0 @@
----
-name: Ask a question
-about: Something is unclear
-title: ''
-labels: 'type:docs'
-assignees: ''
----
-
-This should only be used in very rare cases e.g. if you are not 100% sure if something is a bug or asking a question that leads to improving the documentation. For general questions please use [discord](https://discord.gg/nthXNEv) or the Ethereum stack exchange at https://ethereum.stackexchange.com.

.gitignore

@@ -24,7 +24,6 @@ build/_vendor/pkg
 
 # used by the Makefile
 /build/_workspace/
-/build/cache/
 /build/bin/
 /geth*.zip
 
@@ -43,7 +42,6 @@ profile.cov
 /dashboard/assets/node_modules
 /dashboard/assets/stats.json
 /dashboard/assets/bundle.js
-/dashboard/assets/bundle.js.map
 /dashboard/assets/package-lock.json
 
 **/yarn-error.log

.golangci.yml

@@ -1,50 +0,0 @@
-# This file configures github.com/golangci/golangci-lint.
-
-run:
-  timeout: 3m
-  tests: true
-  # default is true. Enables skipping of directories:
-  #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$
-  skip-dirs-use-default: true
-  skip-files:
-    - core/genesis_alloc.go
-
-linters:
-  disable-all: true
-  enable:
-    - deadcode
-    - goconst
-    - goimports
-    - gosimple
-    - govet
-    - ineffassign
-    - misspell
-    # - staticcheck
-    - unconvert
-    # - unused
-    - varcheck
-
-linters-settings:
-  gofmt:
-    simplify: true
-  goconst:
-    min-len: 3 # minimum length of string constant
-    min-occurrences: 6 # minimum number of occurrences
-
-issues:
-  exclude-rules:
-    - path: crypto/blake2b/
-      linters:
-        - deadcode
-    - path: crypto/bn256/cloudflare
-      linters:
-        - deadcode
-    - path: p2p/discv5/
-      linters:
-        - deadcode
-    - path: core/vm/instructions_test.go
-      linters:
-        - goconst
-    - path: cmd/faucet/
-      linters:
-        - deadcode

.travis.yml

@@ -1,22 +1,50 @@
 language: go
 go_import_path: github.com/ethereum/go-ethereum
 sudo: false
-jobs:
-  allow_failures:
-    - stage: build
-      os: osx
-      go: 1.15.x
-      env:
-        - azure-osx
-        - azure-ios
-        - cocoapods-ios
-
+matrix:
   include:
+    - os: linux
+      dist: xenial
+      sudo: required
+      go: 1.10.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.
+    - os: linux
+      dist: xenial
+      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
+
+    - os: osx
+      go: 1.11.x
+      script:
+        - echo "Increase the maximum number of open file descriptors on macOS"
+        - NOFILE=20480
+        - sudo sysctl -w kern.maxfiles=$NOFILE
+        - sudo sysctl -w kern.maxfilesperproc=$NOFILE
+        - sudo launchctl limit maxfiles $NOFILE $NOFILE
+        - sudo launchctl limit maxfiles
+        - ulimit -S -n $NOFILE
+        - ulimit -n
+        - unset -f cd # workaround for https://github.com/travis-ci/travis-ci/issues/8703
+        - 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
-    - stage: lint
-      os: linux
-      dist: bionic
-      go: 1.16.x
+    - os: linux
+      dist: xenial
+      go: 1.11.x
       env:
         - lint
       git:
@@ -25,14 +53,12 @@ jobs:
         - go run build/ci.go lint
 
     # This builder does the Ubuntu PPA upload
-    - stage: build
-      if: type = push
+    - if: type = push
       os: linux
-      dist: bionic
-      go: 1.16.x
+      dist: xenial
+      go: 1.11.x
       env:
         - ubuntu-ppa
-        - GO111MODULE=on
       git:
         submodules: false # avoid cloning ethereum/tests
       addons:
@@ -49,15 +75,13 @@ jobs:
         - go run build/ci.go debsrc -upload ethereum/ethereum -sftp-user geth-ci -signer "Go Ethereum Linux Builder <geth-ci@ethereum.org>"
 
     # This builder does the Linux Azure uploads
-    - stage: build
-      if: type = push
+    - if: type = push
       os: linux
-      dist: bionic
+      dist: xenial
       sudo: required
-      go: 1.16.x
+      go: 1.11.x
       env:
         - azure-linux
-        - GO111MODULE=on
       git:
         submodules: false # avoid cloning ethereum/tests
       addons:
@@ -66,107 +90,103 @@ jobs:
             - gcc-multilib
       script:
         # Build for the primary platforms that Trusty can manage
-        - go run build/ci.go install -dlgo
-        - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
-        - go run build/ci.go install -dlgo -arch 386
-        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
+        - 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 install -arch 386
+        - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/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 -dlgo -arch arm -cc arm-linux-gnueabi-gcc
-        - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
-        - GOARM=6 go run build/ci.go install -dlgo -arch arm -cc arm-linux-gnueabi-gcc
-        - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
-        - GOARM=7 go run build/ci.go install -dlgo -arch arm -cc arm-linux-gnueabihf-gcc
-        - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
-        - go run build/ci.go install -dlgo -arch arm64 -cc aarch64-linux-gnu-gcc
-        - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
+        - 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=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=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
+        - 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
 
     # This builder does the Linux Azure MIPS xgo uploads
-    - stage: build
-      if: type = push
+    - if: type = push
       os: linux
-      dist: bionic
+      dist: xenial
       services:
         - docker
-      go: 1.16.x
+      go: 1.11.x
       env:
         - azure-linux-mips
-        - GO111MODULE=on
       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 -signify SIGNIFY_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mips -type tar -signer LINUX_SIGNING_KEY -upload gethstore/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 -signify SIGNIFY_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mipsle -type tar -signer LINUX_SIGNING_KEY -upload gethstore/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 signify SIGNIFY_KEY -upload gethstore/builds
+        - go run build/ci.go archive -arch mips64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/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 -signify SIGNIFY_KEY -upload gethstore/builds
+        - 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
+    - if: type = push
       os: linux
-      dist: bionic
+      dist: xenial
       addons:
         apt:
           packages:
-            - openjdk-8-jdk
+            - 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
-        - GO111MODULE=on
       git:
         submodules: false # avoid cloning ethereum/tests
       before_install:
-        # Install Android and it's dependencies manually, Travis is stale
-        - export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
-        - curl https://dl.google.com/android/repository/commandlinetools-linux-6858069_latest.zip -o android.zip
-        - unzip -q android.zip -d $HOME/sdk && rm android.zip
-        - mv $HOME/sdk/cmdline-tools $HOME/sdk/latest && mkdir $HOME/sdk/cmdline-tools && mv $HOME/sdk/latest $HOME/sdk/cmdline-tools
-        - export PATH=$PATH:$HOME/sdk/cmdline-tools/latest/bin
-        - export ANDROID_HOME=$HOME/sdk
-
-        - yes | sdkmanager --licenses >/dev/null
-        - sdkmanager "platform-tools" "platforms;android-15" "platforms;android-19" "platforms;android-24" "ndk-bundle"
-
-        # Install Go to allow building with
-        - curl https://dl.google.com/go/go1.16.linux-amd64.tar.gz | tar -xz
+        - curl https://storage.googleapis.com/golang/go1.11.5.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-r17b-linux-x86_64.zip -o android-ndk-r17b.zip
+        - unzip -q android-ndk-r17b.zip && rm android-ndk-r17b.zip
+        - mv android-ndk-r17b $HOME
+        - export ANDROID_NDK=$HOME/android-ndk-r17b
+
         - 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 -signify SIGNIFY_KEY  -deploy https://oss.sonatype.org -upload gethstore/builds
+        - ln -s `pwd` $GOPATH/src/github.com/ethereum
+        - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/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.16.x
+      go: 1.11.x
       env:
         - azure-osx
         - azure-ios
         - cocoapods-ios
-        - GO111MODULE=on
       git:
         submodules: false # avoid cloning ethereum/tests
       script:
-        - go run build/ci.go install -dlgo
-        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -signify SIGNIFY_KEY -upload gethstore/builds
+        - go run build/ci.go install
+        - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds
 
         # Build the iOS framework and upload it to CocoaPods and Azure
         - gem uninstall cocoapods -a -x
@@ -181,48 +201,15 @@ jobs:
 
         # 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 -signify SIGNIFY_KEY -deploy trunk -upload gethstore/builds
-
-    # These builders run the tests
-    - stage: build
-      os: linux
-      arch: amd64
-      dist: bionic
-      go: 1.16.x
-      env:
-        - GO111MODULE=on
-      script:
-        - go run build/ci.go test -coverage $TEST_PACKAGES
-
-    - stage: build
-      if: type = pull_request
-      os: linux
-      arch: arm64
-      dist: bionic
-      go: 1.16.x
-      env:
-        - GO111MODULE=on
-      script:
-        - go run build/ci.go test -coverage $TEST_PACKAGES
-
-    - stage: build
-      os: linux
-      dist: bionic
-      go: 1.15.x
-      env:
-        - GO111MODULE=on
-      script:
-        - go run build/ci.go test -coverage $TEST_PACKAGES
+        - 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: bionic
-      go: 1.16.x
+      dist: xenial
+      go: 1.11.x
       env:
         - azure-purge
-        - GO111MODULE=on
       git:
         submodules: false # avoid cloning ethereum/tests
       script:

AUTHORS

@@ -1,11 +1,5 @@
 # This is the official list of go-ethereum authors for copyright purposes.
 
-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>
@@ -16,354 +10,165 @@ 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>
+RJ Catalano <catalanor0220@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 Lé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>
+am2rican5 <am2rican5@gmail.com>
+ayeowch <ayeowch@gmail.com>
+b00ris <b00ris@mail.ru>
+bailantaotao <Edwin@maicoin.com>
+baizhenxuan <nkbai@163.com>
+bloonfield <bloonfield@163.com>
+changhong <changhong.yu@shanbay.com>
+evgk <evgeniy.kamyshev@gmail.com>
+ferhat elmas <elmas.ferhat@gmail.com>
+holisticode <holistic.computing@gmail.com>
+jtakalai <juuso.takalainen@streamr.com>
+ken10100147 <sunhongping@kanjian.com>
+ligi <ligi@ligi.de>
+mark.lin <mark@maicoin.com>
+necaremus <necaremus@gmail.com>
+njupt-moon <1015041018@njupt.edu.cn>
+nkbai <nkbai@163.com>
+rhaps107 <dod-source@yandex.ru>
+slumber1122 <slumber1122@gmail.com>
+sunxiaojun2014 <sunxiaojun-xy@360.cn>
+terasum <terasum@163.com>
+tsarpaul <Litvakpol@012.net.il>
+xiekeyang <xiekeyang@users.noreply.github.com>
+yoza <yoza.is12s@gmail.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>
+Ralph Caraveo <deckarep@gmail.com>

COPYING

@@ -1,7 +1,7 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2014 The go-ethereum Authors.
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -617,58 +617,3 @@ reviewing courts shall apply local law that most closely approximates
 an absolute waiver of all civil liability in connection with the
 Program, unless a warranty or assumption of liability accompanies a
 copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program 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 General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

Dockerfile

@@ -1,7 +1,7 @@
 # Build Geth in a stock Go builder container
-FROM golang:1.16-alpine as builder
+FROM golang:1.11-alpine as builder
 
-RUN apk add --no-cache make gcc musl-dev linux-headers git
+RUN apk add --no-cache make gcc musl-dev linux-headers
 
 ADD . /go-ethereum
 RUN cd /go-ethereum && make geth

Dockerfile.alltools

@@ -1,7 +1,7 @@
 # Build Geth in a stock Go builder container
-FROM golang:1.16-alpine as builder
+FROM golang:1.11-alpine as builder
 
-RUN apk add --no-cache make gcc musl-dev linux-headers git
+RUN apk add --no-cache make gcc musl-dev linux-headers
 
 ADD . /go-ethereum
 RUN cd /go-ethereum && make all

Makefile

@@ -2,44 +2,46 @@
 # 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 android ios geth-cross swarm 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 = ./build/bin
+GOBIN = $(shell pwd)/build/bin
 GO ?= latest
-GORUN = env GO111MODULE=on go run
 
 geth:
-	$(GORUN) build/ci.go install ./cmd/geth
+	build/env.sh go run build/ci.go install ./cmd/geth
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/geth\" to launch geth."
 
+swarm:
+	build/env.sh go run build/ci.go install ./cmd/swarm
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/swarm\" to launch swarm."
+
 all:
-	$(GORUN) build/ci.go install
+	build/env.sh go run build/ci.go install
 
 android:
-	$(GORUN) build/ci.go aar --local
+	build/env.sh go run build/ci.go aar --local
 	@echo "Done building."
 	@echo "Import \"$(GOBIN)/geth.aar\" to use the library."
-	@echo "Import \"$(GOBIN)/geth-sources.jar\" to add javadocs"
-	@echo "For more info see https://stackoverflow.com/questions/20994336/android-studio-how-to-attach-javadoc"
 
 ios:
-	$(GORUN) build/ci.go xcode --local
+	build/env.sh go run build/ci.go xcode --local
 	@echo "Done building."
 	@echo "Import \"$(GOBIN)/Geth.framework\" to use the library."
 
 test: all
-	$(GORUN) build/ci.go test
+	build/env.sh go run build/ci.go test
 
 lint: ## Run linters.
-	$(GORUN) build/ci.go lint
+	build/env.sh go run build/ci.go lint
 
 clean:
-	env GO111MODULE=on go clean -cache
+	./build/clean_go_build_cache.sh
 	rm -fr build/_workspace/pkg/ $(GOBIN)/*
 
 # The devtools target installs tools required for 'go generate'.
@@ -55,6 +57,9 @@ devtools:
 	@type "solc" 2> /dev/null || echo 'Please install solc'
 	@type "protoc" 2> /dev/null || echo 'Please install protoc'
 
+swarm-devtools:
+	env GOBIN= go install ./cmd/swarm/mimegen
+
 # Cross Compilation Targets (xgo)
 
 geth-cross: geth-linux geth-darwin geth-windows geth-android geth-ios
@@ -66,12 +71,12 @@ geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm geth-linux-mips64 get
 	@ls -ld $(GOBIN)/geth-linux-*
 
 geth-linux-386:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/386 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/amd64 -v ./cmd/geth
+	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
 
@@ -80,42 +85,42 @@ geth-linux-arm: geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-ar
 	@ls -ld $(GOBIN)/geth-linux-* | grep arm
 
 geth-linux-arm-5:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/arm-5 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/arm-6 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/arm-7 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/arm64 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/mips --ldflags '-extldflags "-static"' -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/mipsle --ldflags '-extldflags "-static"' -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/mips64 --ldflags '-extldflags "-static"' -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=linux/mips64le --ldflags '-extldflags "-static"' -v ./cmd/geth
+	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
 
@@ -124,12 +129,12 @@ geth-darwin: geth-darwin-386 geth-darwin-amd64
 	@ls -ld $(GOBIN)/geth-darwin-*
 
 geth-darwin-386:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=darwin/386 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=darwin/amd64 -v ./cmd/geth
+	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
 
@@ -138,11 +143,11 @@ geth-windows: geth-windows-386 geth-windows-amd64
 	@ls -ld $(GOBIN)/geth-windows-*
 
 geth-windows-386:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=windows/386 -v ./cmd/geth
+	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:
-	$(GORUN) build/ci.go xgo -- --go=$(GO) --targets=windows/amd64 -v ./cmd/geth
+	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

README.md

@@ -1,359 +1,311 @@
 ## Go Ethereum
 
-Official Golang implementation of the Ethereum protocol.
+Official golang implementation of the Ethereum protocol.
 
 [![API Reference](
 https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667
-)](https://pkg.go.dev/github.com/ethereum/go-ethereum?tab=doc)
+)](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.com/ethereum/go-ethereum.svg?branch=master)](https://travis-ci.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)
 
-Automated builds are available for stable releases and the unstable master branch. Binary
-archives are published at https://geth.ethereum.org/downloads/.
+Automated builds are available for stable releases and the unstable master branch.
+Binary archives are published at https://geth.ethereum.org/downloads/.
 
 ## Building the source
 
-For prerequisites and detailed build instructions please read the [Installation Instructions](https://geth.ethereum.org/docs/install-and-build/installing-geth).
+For prerequisites and detailed build instructions please read the
+[Installation Instructions](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum)
+on the wiki.
 
-Building `geth` requires both a Go (version 1.13 or later) and a C compiler. You can install
-them using your favourite package manager. Once the dependencies are installed, run
+Building geth requires both a Go (version 1.9 or later) and a C compiler.
+You can install them using your favourite package manager.
+Once the dependencies are installed, run
 
-```shell
-make geth
-```
+    make geth
 
 or, to build the full suite of utilities:
 
-```shell
-make all
-```
+    make all
 
 ## Executables
 
-The go-ethereum project comes with several wrappers/executables found in the `cmd`
-directory.
+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 page](https://geth.ethereum.org/docs/interface/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://docs.soliditylang.org/en/develop/abi-spec.html) 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://geth.ethereum.org/docs/dapp/native-bindings) page for details. |
+|:----------:|-------------|
+| **`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 run`).                                                                                                                                                                                                                                                                     |
-| `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://eth.wiki/json-rpc/API) 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://eth.wiki/en/fundamentals/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`).                                                                                                                                                                                                                                 |
+| `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`). |
+| `swarm`    | Swarm daemon and tools. This is the entrypoint for the Swarm network. `swarm --help` for command line options and subcommands. See [Swarm README](https://github.com/ethereum/go-ethereum/tree/master/swarm) for more information. |
 | `puppeth`    | a CLI wizard that aids in creating a new Ethereum network. |
 
-## Running `geth`
+## Running geth
 
 Going through all the possible command line flags is out of scope here (please consult our
-[CLI Wiki page](https://geth.ethereum.org/docs/interface/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.
+[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:
+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
 ```
 
 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://geth.ethereum.org/docs/interface/javascript-console),
-   (via the trailing `console` subcommand) through which you can invoke all official [`web3` methods](https://web3js.readthedocs.io/en/)
-   as well as `geth`'s own [management APIs](https://geth.ethereum.org/docs/rpc/server).
-   This tool is optional and if you leave it out you can always attach to an already running
-   `geth` instance with `geth attach`.
 
-### A Full node on the Görli test network
+ * 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`.
 
-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.
+### Full node on the Ethereum test network
 
-```shell
-$ geth --goerli console
+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.
+
+```
+$ geth --testnet console
 ```
 
-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.
+The `console` subcommand have 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 to here.
 
-Specifying the `--goerli` flag, however, will reconfigure your `geth` instance a bit:
+Specifying the `--testnet` flag however will reconfigure your Geth instance a bit:
 
- * Instead of connecting the main Ethereum network, the client will connect to the Görli
-   test network, which uses different P2P bootnodes, different network IDs and genesis
-   states.
- * Instead of using the default data directory (`~/.ethereum` on Linux for example), `geth`
-   will nest itself one level deeper into a `goerli` subfolder (`~/.ethereum/goerli` 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>/goerli/geth.ipc`. Windows users are not affected by
-   this.
+ * 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.*
+*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
 
-Go Ethereum also supports connecting to the older proof-of-authority based test network
-called [*Rinkeby*](https://www.rinkeby.io) which is operated by members of the community.
+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
 ```
 
-### Full node on the Ropsten test network
-
-In addition to Görli and Rinkeby, Geth also supports the ancient Ropsten testnet. The
-Ropsten test network is 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.
-
-```shell
-$ geth --ropsten console
-```
-
-*Note: Older Geth configurations store the Ropsten database in the `testnet` subdirectory.*
-
 ### Configuration
 
-As an alternative to passing the numerous flags to the `geth` binary, you can also pass a
-configuration file via:
+As an alternative to passing the numerous flags to the `geth` binary, you can also pass a configuration file via:
 
-```shell
+```
 $ geth --config /path/to/your_config.toml
 ```
 
-To get an idea how the file should look like you can use the `dumpconfig` subcommand to
-export your existing configuration:
+To get an idea how the file should look like you can use the `dumpconfig` subcommand to export your existing configuration:
 
-```shell
+```
 $ geth --your-favourite-flags dumpconfig
 ```
 
-*Note: This works only with `geth` v1.6.0 and above.*
+*Note: This works only with geth v1.6.0 and above.*
 
 #### Docker quick start
 
-One of the quickest ways to get Ethereum up and running on your machine is by using
-Docker:
+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
 ```
 
-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.
+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.
 
-Do not forget `--http.addr 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.
+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
+### Programatically 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://eth.wiki/json-rpc/API)
-and [`geth` specific APIs](https://geth.ethereum.org/docs/rpc/server)).
-These can be exposed via HTTP, WebSockets and IPC (UNIX sockets on UNIX based
-platforms, and named pipes on Windows).
+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.
+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:
 
-  * `--http` Enable the HTTP-RPC server
-  * `--http.addr` HTTP-RPC server listening interface (default: `localhost`)
-  * `--http.port` HTTP-RPC server listening port (default: `8545`)
-  * `--http.api` API's offered over the HTTP-RPC interface (default: `eth,net,web3`)
-  * `--http.corsdomain` Comma separated list of domains from which to accept cross origin requests (browser enforced)
+  * `--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
-  * `--ws.addr` WS-RPC server listening interface (default: `localhost`)
-  * `--ws.port` WS-RPC server listening port (default: `8546`)
-  * `--ws.api` API's offered over the WS-RPC interface (default: `eth,net,web3`)
-  * `--ws.origins` Origins from which to accept websockets requests
+  * `--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`)
+  * `--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!
+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!**
+**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 webservers, so malicious webpages 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.
+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`):
+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": <arbitrary positive integer>,
+        "chainId": 0,
         "homesteadBlock": 0,
-    "eip150Block": 0,
         "eip155Block": 0,
-    "eip158Block": 0,
-    "byzantiumBlock": 0,
-    "constantinopleBlock": 0,
-    "petersburgBlock": 0,
-    "istanbulBlock": 0
+        "eip158Block": 0
     },
-  "alloc": {},
-  "coinbase": "0x0000000000000000000000000000000000000000",
-  "difficulty": "0x20000",
-  "extraData": "",
-  "gasLimit": "0x2fefd8",
-  "nonce": "0x0000000000000042",
-  "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-  "timestamp": "0x00"
+  "alloc"      : {},
+  "coinbase"   : "0x0000000000000000000000000000000000000000",
+  "difficulty" : "0x20000",
+  "extraData"  : "",
+  "gasLimit"   : "0x2fefd8",
+  "nonce"      : "0x0000000000000042",
+  "mixhash"    : "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "timestamp"  : "0x00"
 }
 ```
 
-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, create
-the accounts and populate the `alloc` field with their addresses.
+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:
 
 ```json
 "alloc": {
-  "0x0000000000000000000000000000000000000001": {
-    "balance": "111111111"
-  },
-  "0x0000000000000000000000000000000000000002": {
-    "balance": "222222222"
-  }
+  "0x0000000000000000000000000000000000000001": {"balance": "111111111"},
+  "0x0000000000000000000000000000000000000002": {"balance": "222222222"}
 }
 ```
 
-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:
+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:
 
-```shell
+```
 $ geth init path/to/genesis.json
 ```
 
 #### Creating the rendezvous point
 
-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:
+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:
 
-```shell
+```
 $ bootnode --genkey=boot.key
 $ bootnode --nodekey=boot.key
 ```
 
-With the bootnode online, it will display an [`enode` URL](https://eth.wiki/en/fundamentals/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.
+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.*
+*Note: You could also use a full fledged Geth node as a bootnode, but it's the less recommended way.*
 
 #### Starting up your member nodes
 
-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.
+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.
 
-```shell
+```
 $ geth --datadir=path/to/custom/data/folder --bootnodes=<bootnode-enode-url-from-above>
 ```
 
-*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: 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.*
 
 #### Running a private miner
 
-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 [ethminer](https://github.com/ethereum-mining/ethminer) repository.
+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:
+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 --miner.threads=1 --miner.etherbase=0x0000000000000000000000000000000000000000
+```
+$ geth <usual-flags> --mine --minerthreads=1 --etherbase=0x0000000000000000000000000000000000000000
 ```
 
-Which will start mining blocks and transactions on a single CPU thread, crediting all
-proceedings to the account specified by `--miner.etherbase`. You can further tune the mining
-by changing the default gas limit blocks converge to (`--miner.targetgaslimit`) and the price
-transactions are accepted at (`--miner.gasprice`).
+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`).
 
 ## Contribution
 
-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.
+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.
 
 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.
  * Commit messages should be prefixed with the package(s) they modify.
    * E.g. "eth, rpc: make trace configs optional"
 
-Please see the [Developers' Guide](https://geth.ethereum.org/docs/developers/devguide)
-for more details on configuring your environment, managing project dependencies, and
-testing procedures.
+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.
+[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.
+[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.

SECURITY.md

@@ -1,118 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-Please see [Releases](https://github.com/ethereum/go-ethereum/releases). We recommend using the [most recently released version](https://github.com/ethereum/go-ethereum/releases/latest).
-
-## 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. Please read the [disclosure page](https://github.com/ethereum/go-ethereum/security/advisories?state=published) for more information about publically disclosed security vulnerabilities.
-
-Use the built-in `geth version-check` feature to check whether the software is affected by any known vulnerability. This command will fetch the latest [`vulnerabilities.json`](https://geth.ethereum.org/docs/vulnerabilities/vulnerabilities.json) file which contains known security vulnerabilities concerning `geth`, and cross-check the data against its own version number.
-
-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-----
-```

accounts/abi/abi.go

@@ -19,12 +19,8 @@ package abi
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 )
 
 // The ABI holds information about a contract's context and available
@@ -34,12 +30,6 @@ type ABI struct {
 	Constructor Method
 	Methods     map[string]Method
 	Events      map[string]Event
-
-	// Additional "special" functions introduced in solidity v0.6.0.
-	// It's separated from the original default fallback. Each contract
-	// can only define one fallback and receive function.
-	Fallback Method // Note it's also used to represent legacy fallback before v0.6.0
-	Receive  Method
 }
 
 // JSON returns a parsed ABI interface and error if it failed.
@@ -50,6 +40,7 @@ func JSON(reader io.Reader) (ABI, error) {
 	if err := dec.Decode(&abi); err != nil {
 		return ABI{}, err
 	}
+
 	return abi, nil
 }
 
@@ -77,203 +68,80 @@ func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) {
 		return nil, err
 	}
 	// Pack up the method ID too if not a constructor and return
-	return append(method.ID, arguments...), nil
+	return append(method.Id(), arguments...), nil
 }
 
-func (abi ABI) getArguments(name string, data []byte) (Arguments, error) {
+// Unpack output in v according to the abi specification
+func (abi ABI) Unpack(v interface{}, name string, output []byte) (err error) {
+	if len(output) == 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
-	var args Arguments
 	if method, ok := abi.Methods[name]; ok {
-		if len(data)%32 != 0 {
-			return nil, fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(data), data)
+		if len(output)%32 != 0 {
+			return fmt.Errorf("abi: improperly formatted output: %s - Bytes: [%+v]", string(output), output)
 		}
-		args = method.Outputs
+		return method.Outputs.Unpack(v, output)
+	} else if event, ok := abi.Events[name]; ok {
+		return event.Inputs.Unpack(v, output)
 	}
-	if event, ok := abi.Events[name]; ok {
-		args = event.Inputs
-	}
-	if args == nil {
-		return nil, errors.New("abi: could not locate named method or event")
-	}
-	return args, nil
+	return fmt.Errorf("abi: could not locate named method or event")
 }
 
-// Unpack unpacks the output according to the abi specification.
-func (abi ABI) Unpack(name string, data []byte) ([]interface{}, error) {
-	args, err := abi.getArguments(name, data)
-	if err != nil {
-		return nil, err
-	}
-	return args.Unpack(data)
-}
-
-// UnpackIntoInterface unpacks the output in v according to the abi specification.
-// It performs an additional copy. Please only use, if you want to unpack into a
-// structure that does not strictly conform to the abi structure (e.g. has additional arguments)
-func (abi ABI) UnpackIntoInterface(v interface{}, name string, data []byte) error {
-	args, err := abi.getArguments(name, data)
-	if err != nil {
-		return err
-	}
-	unpacked, err := args.Unpack(data)
-	if err != nil {
-		return err
-	}
-	return args.Copy(v, unpacked)
-}
-
-// UnpackIntoMap unpacks a log into the provided map[string]interface{}.
-func (abi ABI) UnpackIntoMap(v map[string]interface{}, name string, data []byte) (err error) {
-	args, err := abi.getArguments(name, data)
-	if err != nil {
-		return err
-	}
-	return args.UnpackIntoMap(v, data)
-}
-
-// UnmarshalJSON implements json.Unmarshaler interface.
+// 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
-
-		// Status indicator which can be: "pure", "view",
-		// "nonpayable" or "payable".
-		StateMutability string
-
-		// Deprecated Status indicators, but removed in v0.6.0.
-		Constant bool // True if function is either pure or view
-		Payable  bool // True if function is payable
-
-		// Event relevant indicator represents the event is
-		// declared as anonymous.
-		Anonymous bool
 	}
+
 	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 = NewMethod("", "", Constructor, field.StateMutability, field.Constant, field.Payable, field.Inputs, nil)
-		case "function":
-			name := abi.overloadedMethodName(field.Name)
-			abi.Methods[name] = NewMethod(name, field.Name, Function, field.StateMutability, field.Constant, field.Payable, field.Inputs, field.Outputs)
-		case "fallback":
-			// New introduced function type in v0.6.0, check more detail
-			// here https://solidity.readthedocs.io/en/v0.6.0/contracts.html#fallback-function
-			if abi.HasFallback() {
-				return errors.New("only single fallback is allowed")
+			abi.Constructor = Method{
+				Inputs: field.Inputs,
 			}
-			abi.Fallback = NewMethod("", "", Fallback, field.StateMutability, field.Constant, field.Payable, nil, nil)
-		case "receive":
-			// New introduced function type in v0.6.0, check more detail
-			// here https://solidity.readthedocs.io/en/v0.6.0/contracts.html#fallback-function
-			if abi.HasReceive() {
-				return errors.New("only single receive is allowed")
+		// empty defaults to function according to the abi spec
+		case "function", "":
+			abi.Methods[field.Name] = Method{
+				Name:    field.Name,
+				Const:   field.Constant,
+				Inputs:  field.Inputs,
+				Outputs: field.Outputs,
 			}
-			if field.StateMutability != "payable" {
-				return errors.New("the statemutability of receive can only be payable")
-			}
-			abi.Receive = NewMethod("", "", Receive, field.StateMutability, field.Constant, field.Payable, nil, nil)
 		case "event":
-			name := abi.overloadedEventName(field.Name)
-			abi.Events[name] = NewEvent(name, field.Name, field.Anonymous, field.Inputs)
-		default:
-			return fmt.Errorf("abi: could not recognize type %v of field %v", field.Type, field.Name)
+			abi.Events[field.Name] = Event{
+				Name:      field.Name,
+				Anonymous: field.Anonymous,
+				Inputs:    field.Inputs,
 			}
 		}
+	}
+
 	return nil
 }
 
-// overloadedMethodName returns the next available name for a given function.
-// Needed since solidity allows for function overload.
-//
-// e.g. if the abi contains Methods send, send1
-// overloadedMethodName would return send2 for input send.
-func (abi *ABI) overloadedMethodName(rawName string) string {
-	name := rawName
-	_, ok := abi.Methods[name]
-	for idx := 0; ok; idx++ {
-		name = fmt.Sprintf("%s%d", rawName, idx)
-		_, ok = abi.Methods[name]
-	}
-	return name
-}
-
-// overloadedEventName returns the next available name for a given event.
-// Needed since solidity allows for event overload.
-//
-// e.g. if the abi contains events received, received1
-// overloadedEventName would return received2 for input received.
-func (abi *ABI) overloadedEventName(rawName string) string {
-	name := rawName
-	_, ok := abi.Events[name]
-	for idx := 0; ok; idx++ {
-		name = fmt.Sprintf("%s%d", rawName, idx)
-		_, ok = abi.Events[name]
-	}
-	return name
-}
-
-// MethodById looks up a method by the 4-byte id,
-// returns nil if none found.
+// 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))
+		return nil, fmt.Errorf("data too short (% bytes) for abi method lookup", len(sigdata))
 	}
 	for _, method := range abi.Methods {
-		if bytes.Equal(method.ID, sigdata[:4]) {
+		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())
-}
-
-// HasFallback returns an indicator whether a fallback function is included.
-func (abi *ABI) HasFallback() bool {
-	return abi.Fallback.Type == Fallback
-}
-
-// HasReceive returns an indicator whether a receive function is included.
-func (abi *ABI) HasReceive() bool {
-	return abi.Receive.Type == Receive
-}
-
-// revertSelector is a special function selector for revert reason unpacking.
-var revertSelector = crypto.Keccak256([]byte("Error(string)"))[:4]
-
-// UnpackRevert resolves the abi-encoded revert reason. According to the solidity
-// spec https://solidity.readthedocs.io/en/latest/control-structures.html#revert,
-// the provided revert reason is abi-encoded as if it were a call to a function
-// `Error(string)`. So it's a special tool for it.
-func UnpackRevert(data []byte) (string, error) {
-	if len(data) < 4 {
-		return "", errors.New("invalid data for unpacking")
-	}
-	if !bytes.Equal(data[:4], revertSelector) {
-		return "", errors.New("invalid data for unpacking")
-	}
-	typ, _ := NewType("string", "", nil)
-	unpacked, err := (Arguments{{Type: typ}}).Unpack(data[4:])
-	if err != nil {
-		return "", err
-	}
-	return unpacked[0].(string), nil
-}

accounts/abi/abi_test.go

@@ -19,116 +19,65 @@ package abi
 import (
 	"bytes"
 	"encoding/hex"
-	"errors"
 	"fmt"
+	"log"
 	"math/big"
 	"reflect"
 	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
 const jsondata = `
 [
-	{ "type" : "function", "name" : ""},
-	{ "type" : "function", "name" : "balance", "stateMutability" : "view" },
-	{ "type" : "function", "name" : "send", "inputs" : [ { "name" : "amount", "type" : "uint256" } ] },
-	{ "type" : "function", "name" : "test", "inputs" : [ { "name" : "number", "type" : "uint32" } ] },
-	{ "type" : "function", "name" : "string", "inputs" : [ { "name" : "inputs", "type" : "string" } ] },
-	{ "type" : "function", "name" : "bool", "inputs" : [ { "name" : "inputs", "type" : "bool" } ] },
-	{ "type" : "function", "name" : "address", "inputs" : [ { "name" : "inputs", "type" : "address" } ] },
-	{ "type" : "function", "name" : "uint64[2]", "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] },
-	{ "type" : "function", "name" : "uint64[]", "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] },
-	{ "type" : "function", "name" : "int8", "inputs" : [ { "name" : "inputs", "type" : "int8" } ] },
-	{ "type" : "function", "name" : "bytes32", "inputs" : [ { "name" : "inputs", "type" : "bytes32" } ] },
-	{ "type" : "function", "name" : "foo", "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] },
-	{ "type" : "function", "name" : "bar", "inputs" : [ { "name" : "inputs", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] },
-	{ "type" : "function", "name" : "slice", "inputs" : [ { "name" : "inputs", "type" : "uint32[2]" } ] },
-	{ "type" : "function", "name" : "slice256", "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] },
-	{ "type" : "function", "name" : "sliceAddress", "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] },
-	{ "type" : "function", "name" : "sliceMultiAddress", "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] },
-	{ "type" : "function", "name" : "nestedArray", "inputs" : [ { "name" : "a", "type" : "uint256[2][2]" }, { "name" : "b", "type" : "address[]" } ] },
-	{ "type" : "function", "name" : "nestedArray2", "inputs" : [ { "name" : "a", "type" : "uint8[][2]" } ] },
-	{ "type" : "function", "name" : "nestedSlice", "inputs" : [ { "name" : "a", "type" : "uint8[][]" } ] },
-	{ "type" : "function", "name" : "receive", "inputs" : [ { "name" : "memo", "type" : "bytes" }], "outputs" : [], "payable" : true, "stateMutability" : "payable" },
-	{ "type" : "function", "name" : "fixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
-	{ "type" : "function", "name" : "fixedArrBytes", "stateMutability" : "view", "inputs" : [ { "name" : "bytes", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
-	{ "type" : "function", "name" : "mixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" } ] },
-	{ "type" : "function", "name" : "doubleFixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type" : "uint256[2]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] },
-	{ "type" : "function", "name" : "multipleMixedArrStr", "stateMutability" : "view", "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type" : "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] },
-	{ "type" : "function", "name" : "overloadedNames", "stateMutability" : "view", "inputs": [ { "components": [ { "internalType": "uint256", "name": "_f",	"type": "uint256" }, { "internalType": "uint256", "name": "__f", "type": "uint256"}, { "internalType": "uint256", "name": "f", "type": "uint256"}],"internalType": "struct Overloader.F", "name": "f","type": "tuple"}]}
+	{ "type" : "function", "name" : "balance", "constant" : true },
+	{ "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] }
 ]`
 
-var (
-	Uint256, _    = NewType("uint256", "", nil)
-	Uint32, _     = NewType("uint32", "", nil)
-	Uint16, _     = NewType("uint16", "", nil)
-	String, _     = NewType("string", "", nil)
-	Bool, _       = NewType("bool", "", nil)
-	Bytes, _      = NewType("bytes", "", nil)
-	Bytes32, _    = NewType("bytes32", "", nil)
-	Address, _    = NewType("address", "", nil)
-	Uint64Arr, _  = NewType("uint64[]", "", nil)
-	AddressArr, _ = NewType("address[]", "", nil)
-	Int8, _       = NewType("int8", "", nil)
-	// Special types for testing
-	Uint32Arr2, _       = NewType("uint32[2]", "", nil)
-	Uint64Arr2, _       = NewType("uint64[2]", "", nil)
-	Uint256Arr, _       = NewType("uint256[]", "", nil)
-	Uint256Arr2, _      = NewType("uint256[2]", "", nil)
-	Uint256Arr3, _      = NewType("uint256[3]", "", nil)
-	Uint256ArrNested, _ = NewType("uint256[2][2]", "", nil)
-	Uint8ArrNested, _   = NewType("uint8[][2]", "", nil)
-	Uint8SliceNested, _ = NewType("uint8[][]", "", nil)
-	TupleF, _           = NewType("tuple", "struct Overloader.F", []ArgumentMarshaling{
-		{Name: "_f", Type: "uint256"},
-		{Name: "__f", Type: "uint256"},
-		{Name: "f", Type: "uint256"}})
-)
-
-var methods = map[string]Method{
-	"":                    NewMethod("", "", Function, "", false, false, nil, nil),
-	"balance":             NewMethod("balance", "balance", Function, "view", false, false, nil, nil),
-	"send":                NewMethod("send", "send", Function, "", false, false, []Argument{{"amount", Uint256, false}}, nil),
-	"test":                NewMethod("test", "test", Function, "", false, false, []Argument{{"number", Uint32, false}}, nil),
-	"string":              NewMethod("string", "string", Function, "", false, false, []Argument{{"inputs", String, false}}, nil),
-	"bool":                NewMethod("bool", "bool", Function, "", false, false, []Argument{{"inputs", Bool, false}}, nil),
-	"address":             NewMethod("address", "address", Function, "", false, false, []Argument{{"inputs", Address, false}}, nil),
-	"uint64[]":            NewMethod("uint64[]", "uint64[]", Function, "", false, false, []Argument{{"inputs", Uint64Arr, false}}, nil),
-	"uint64[2]":           NewMethod("uint64[2]", "uint64[2]", Function, "", false, false, []Argument{{"inputs", Uint64Arr2, false}}, nil),
-	"int8":                NewMethod("int8", "int8", Function, "", false, false, []Argument{{"inputs", Int8, false}}, nil),
-	"bytes32":             NewMethod("bytes32", "bytes32", Function, "", false, false, []Argument{{"inputs", Bytes32, false}}, nil),
-	"foo":                 NewMethod("foo", "foo", Function, "", false, false, []Argument{{"inputs", Uint32, false}}, nil),
-	"bar":                 NewMethod("bar", "bar", Function, "", false, false, []Argument{{"inputs", Uint32, false}, {"string", Uint16, false}}, nil),
-	"slice":               NewMethod("slice", "slice", Function, "", false, false, []Argument{{"inputs", Uint32Arr2, false}}, nil),
-	"slice256":            NewMethod("slice256", "slice256", Function, "", false, false, []Argument{{"inputs", Uint256Arr2, false}}, nil),
-	"sliceAddress":        NewMethod("sliceAddress", "sliceAddress", Function, "", false, false, []Argument{{"inputs", AddressArr, false}}, nil),
-	"sliceMultiAddress":   NewMethod("sliceMultiAddress", "sliceMultiAddress", Function, "", false, false, []Argument{{"a", AddressArr, false}, {"b", AddressArr, false}}, nil),
-	"nestedArray":         NewMethod("nestedArray", "nestedArray", Function, "", false, false, []Argument{{"a", Uint256ArrNested, false}, {"b", AddressArr, false}}, nil),
-	"nestedArray2":        NewMethod("nestedArray2", "nestedArray2", Function, "", false, false, []Argument{{"a", Uint8ArrNested, false}}, nil),
-	"nestedSlice":         NewMethod("nestedSlice", "nestedSlice", Function, "", false, false, []Argument{{"a", Uint8SliceNested, false}}, nil),
-	"receive":             NewMethod("receive", "receive", Function, "payable", false, true, []Argument{{"memo", Bytes, false}}, []Argument{}),
-	"fixedArrStr":         NewMethod("fixedArrStr", "fixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr", Uint256Arr2, false}}, nil),
-	"fixedArrBytes":       NewMethod("fixedArrBytes", "fixedArrBytes", Function, "view", false, false, []Argument{{"bytes", Bytes, false}, {"fixedArr", Uint256Arr2, false}}, nil),
-	"mixedArrStr":         NewMethod("mixedArrStr", "mixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr", Uint256Arr2, false}, {"dynArr", Uint256Arr, false}}, nil),
-	"doubleFixedArrStr":   NewMethod("doubleFixedArrStr", "doubleFixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr1", Uint256Arr2, false}, {"fixedArr2", Uint256Arr3, false}}, nil),
-	"multipleMixedArrStr": NewMethod("multipleMixedArrStr", "multipleMixedArrStr", Function, "view", false, false, []Argument{{"str", String, false}, {"fixedArr1", Uint256Arr2, false}, {"dynArr", Uint256Arr, false}, {"fixedArr2", Uint256Arr3, false}}, nil),
-	"overloadedNames":     NewMethod("overloadedNames", "overloadedNames", Function, "view", false, false, []Argument{{"f", TupleF, false}}, nil),
-}
+const jsondata2 = `
+[
+	{ "type" : "function", "name" : "balance", "constant" : true },
+	{ "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "type" : "uint256" } ] },
+	{ "type" : "function", "name" : "test", "constant" : false, "inputs" : [ { "name" : "number", "type" : "uint32" } ] },
+	{ "type" : "function", "name" : "string", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "string" } ] },
+	{ "type" : "function", "name" : "bool", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "bool" } ] },
+	{ "type" : "function", "name" : "address", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "address" } ] },
+	{ "type" : "function", "name" : "uint64[2]", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[2]" } ] },
+	{ "type" : "function", "name" : "uint64[]", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint64[]" } ] },
+	{ "type" : "function", "name" : "foo", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" } ] },
+	{ "type" : "function", "name" : "bar", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32" }, { "name" : "string", "type" : "uint16" } ] },
+	{ "type" : "function", "name" : "slice", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint32[2]" } ] },
+	{ "type" : "function", "name" : "slice256", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "uint256[2]" } ] },
+	{ "type" : "function", "name" : "sliceAddress", "constant" : false, "inputs" : [ { "name" : "inputs", "type" : "address[]" } ] },
+	{ "type" : "function", "name" : "sliceMultiAddress", "constant" : false, "inputs" : [ { "name" : "a", "type" : "address[]" }, { "name" : "b", "type" : "address[]" } ] },
+	{ "type" : "function", "name" : "nestedArray", "constant" : false, "inputs" : [ { "name" : "a", "type" : "uint256[2][2]" }, { "name" : "b", "type" : "address[]" } ] },
+	{ "type" : "function", "name" : "nestedArray2", "constant" : false, "inputs" : [ { "name" : "a", "type" : "uint8[][2]" } ] },
+	{ "type" : "function", "name" : "nestedSlice", "constant" : false, "inputs" : [ { "name" : "a", "type" : "uint8[][]" } ] }
+]`
 
 func TestReader(t *testing.T) {
-	abi := ABI{
-		Methods: methods,
+	Uint256, _ := NewType("uint256", nil)
+	exp := ABI{
+		Methods: map[string]Method{
+			"balance": {
+				"balance", true, nil, nil,
+			},
+			"send": {
+				"send", false, []Argument{
+					{"amount", Uint256, false},
+				}, nil,
+			},
+		},
 	}
 
-	exp, err := JSON(strings.NewReader(jsondata))
+	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
+	// deep equal fails for some reason
 	for name, expM := range exp.Methods {
 		gotM, exist := abi.Methods[name]
 		if !exist {
@@ -150,57 +99,11 @@ func TestReader(t *testing.T) {
 	}
 }
 
-func TestInvalidABI(t *testing.T) {
-	json := `[{ "type" : "function", "name" : "", "constant" : fals }]`
-	_, err := JSON(strings.NewReader(json))
-	if err == nil {
-		t.Fatal("invalid json should produce error")
-	}
-	json2 := `[{ "type" : "function", "name" : "send", "constant" : false, "inputs" : [ { "name" : "amount", "typ" : "uint256" } ] }]`
-	_, err = JSON(strings.NewReader(json2))
-	if err == nil {
-		t.Fatal("invalid json should produce error")
-	}
-}
-
-// TestConstructor tests a constructor function.
-// The test is based on the following contract:
-// 	contract TestConstructor {
-// 		constructor(uint256 a, uint256 b) public{}
-//	}
-func TestConstructor(t *testing.T) {
-	json := `[{	"inputs": [{"internalType": "uint256","name": "a","type": "uint256"	},{	"internalType": "uint256","name": "b","type": "uint256"}],"stateMutability": "nonpayable","type": "constructor"}]`
-	method := NewMethod("", "", Constructor, "nonpayable", false, false, []Argument{{"a", Uint256, false}, {"b", Uint256, false}}, nil)
-	// Test from JSON
-	abi, err := JSON(strings.NewReader(json))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !reflect.DeepEqual(abi.Constructor, method) {
-		t.Error("Missing expected constructor")
-	}
-	// Test pack/unpack
-	packed, err := abi.Pack("", big.NewInt(1), big.NewInt(2))
-	if err != nil {
-		t.Error(err)
-	}
-	unpacked, err := abi.Constructor.Inputs.Unpack(packed)
-	if err != nil {
-		t.Error(err)
-	}
-
-	if !reflect.DeepEqual(unpacked[0], big.NewInt(1)) {
-		t.Error("Unable to pack/unpack from constructor")
-	}
-	if !reflect.DeepEqual(unpacked[1], big.NewInt(2)) {
-		t.Error("Unable to pack/unpack from constructor")
-	}
-}
-
 func TestTestNumbers(t *testing.T) {
-	abi, err := JSON(strings.NewReader(jsondata))
+	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+		t.FailNow()
 	}
 
 	if _, err := abi.Pack("balance"); err != nil {
@@ -234,26 +137,69 @@ func TestTestNumbers(t *testing.T) {
 	}
 }
 
+func TestTestString(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("string", "hello world"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestBool(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	if _, err := abi.Pack("bool", true); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestTestSlice(t *testing.T) {
+	abi, err := JSON(strings.NewReader(jsondata2))
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+
+	slice := make([]uint64, 2)
+	if _, err := abi.Pack("uint64[2]", slice); err != nil {
+		t.Error(err)
+	}
+
+	if _, err := abi.Pack("uint64[]", slice); err != nil {
+		t.Error(err)
+	}
+}
+
 func TestMethodSignature(t *testing.T) {
-	m := NewMethod("foo", "foo", Function, "", false, false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil)
+	String, _ := NewType("string", nil)
+	m := Method{"foo", false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil}
 	exp := "foo(string,string)"
-	if m.Sig != exp {
-		t.Error("signature mismatch", exp, "!=", m.Sig)
+	if m.Sig() != exp {
+		t.Error("signature mismatch", exp, "!=", m.Sig())
 	}
 
 	idexp := crypto.Keccak256([]byte(exp))[:4]
-	if !bytes.Equal(m.ID, idexp) {
-		t.Errorf("expected ids to match %x != %x", m.ID, idexp)
+	if !bytes.Equal(m.Id(), idexp) {
+		t.Errorf("expected ids to match %x != %x", m.Id(), idexp)
 	}
 
-	m = NewMethod("foo", "foo", Function, "", false, false, []Argument{{"bar", Uint256, false}}, nil)
+	uintt, _ := NewType("uint256", nil)
+	m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil}
 	exp = "foo(uint256)"
-	if m.Sig != exp {
-		t.Error("signature mismatch", exp, "!=", m.Sig)
+	if m.Sig() != exp {
+		t.Error("signature mismatch", exp, "!=", m.Sig())
 	}
 
 	// Method with tuple arguments
-	s, _ := NewType("tuple", "", []ArgumentMarshaling{
+	s, _ := NewType("tuple", []ArgumentMarshaling{
 		{Name: "a", Type: "int256"},
 		{Name: "b", Type: "int256[]"},
 		{Name: "c", Type: "tuple[]", Components: []ArgumentMarshaling{
@@ -265,40 +211,18 @@ func TestMethodSignature(t *testing.T) {
 			{Name: "y", Type: "int256"},
 		}},
 	})
-	m = NewMethod("foo", "foo", Function, "", false, false, []Argument{{"s", s, false}, {"bar", String, false}}, nil)
+	m = Method{"foo", false, []Argument{{"s", s, false}, {"bar", String, false}}, nil}
 	exp = "foo((int256,int256[],(int256,int256)[],(int256,int256)[2]),string)"
-	if m.Sig != exp {
-		t.Error("signature mismatch", exp, "!=", m.Sig)
+	if m.Sig() != exp {
+		t.Error("signature mismatch", exp, "!=", m.Sig())
 	}
 }
 
-func TestOverloadedMethodSignature(t *testing.T) {
-	json := `[{"constant":true,"inputs":[{"name":"i","type":"uint256"},{"name":"j","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[{"name":"i","type":"uint256"}],"name":"foo","outputs":[],"payable":false,"stateMutability":"pure","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"}],"name":"bar","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"i","type":"uint256"},{"indexed":false,"name":"j","type":"uint256"}],"name":"bar","type":"event"}]`
-	abi, err := JSON(strings.NewReader(json))
-	if err != nil {
-		t.Fatal(err)
-	}
-	check := func(name string, expect string, method bool) {
-		if method {
-			if abi.Methods[name].Sig != expect {
-				t.Fatalf("The signature of overloaded method mismatch, want %s, have %s", expect, abi.Methods[name].Sig)
-			}
-		} else {
-			if abi.Events[name].Sig != expect {
-				t.Fatalf("The signature of overloaded event mismatch, want %s, have %s", expect, abi.Events[name].Sig)
-			}
-		}
-	}
-	check("foo", "foo(uint256,uint256)", true)
-	check("foo0", "foo(uint256)", true)
-	check("bar", "bar(uint256)", false)
-	check("bar0", "bar(uint256,uint256)", false)
-}
-
 func TestMultiPack(t *testing.T) {
-	abi, err := JSON(strings.NewReader(jsondata))
+	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+		t.FailNow()
 	}
 
 	sig := crypto.Keccak256([]byte("bar(uint32,uint16)"))[:4]
@@ -308,8 +232,10 @@ func TestMultiPack(t *testing.T) {
 
 	packed, err := abi.Pack("bar", uint32(10), uint16(11))
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
+		t.FailNow()
 	}
+
 	if !bytes.Equal(packed, sig) {
 		t.Errorf("expected %x got %x", sig, packed)
 	}
@@ -320,11 +246,11 @@ func ExampleJSON() {
 
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
-		panic(err)
+		log.Fatalln(err)
 	}
 	out, err := abi.Pack("isBar", common.HexToAddress("01"))
 	if err != nil {
-		panic(err)
+		log.Fatalln(err)
 	}
 
 	fmt.Printf("%x\n", out)
@@ -461,7 +387,15 @@ func TestInputVariableInputLength(t *testing.T) {
 }
 
 func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
-	abi, err := JSON(strings.NewReader(jsondata))
+	const definition = `[
+	{ "type" : "function", "name" : "fixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
+	{ "type" : "function", "name" : "fixedArrBytes", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] },
+    { "type" : "function", "name" : "mixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type": "uint256[2]" }, { "name" : "dynArr", "type": "uint256[]" } ] },
+    { "type" : "function", "name" : "doubleFixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "fixedArr2", "type": "uint256[3]" } ] },
+    { "type" : "function", "name" : "multipleMixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] }
+	]`
+
+	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Error(err)
 	}
@@ -608,7 +542,7 @@ func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
 	strvalue = common.RightPadBytes([]byte(strin), 32)
 	fixedarrin1value1 = common.LeftPadBytes(fixedarrin1[0].Bytes(), 32)
 	fixedarrin1value2 = common.LeftPadBytes(fixedarrin1[1].Bytes(), 32)
-	dynarroffset = math.U256Bytes(big.NewInt(int64(256 + ((len(strin)/32)+1)*32)))
+	dynarroffset = U256(big.NewInt(int64(256 + ((len(strin)/32)+1)*32)))
 	dynarrlength = make([]byte, 32)
 	dynarrlength[31] = byte(len(dynarrin))
 	dynarrinvalue1 = common.LeftPadBytes(dynarrin[0].Bytes(), 32)
@@ -635,7 +569,7 @@ func TestInputFixedArrayAndVariableInputLength(t *testing.T) {
 }
 
 func TestDefaultFunctionParsing(t *testing.T) {
-	const definition = `[{ "name" : "balance", "type" : "function" }]`
+	const definition = `[{ "name" : "balance" }]`
 
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
@@ -655,7 +589,9 @@ func TestBareEvents(t *testing.T) {
 	{ "type" : "event", "name" : "tuple", "inputs" : [{ "indexed":false, "name":"t", "type":"tuple", "components":[{"name":"a", "type":"uint256"}] }, { "indexed":true, "name":"arg1", "type":"address" }] }
 	]`
 
-	tuple, _ := NewType("tuple", "", []ArgumentMarshaling{{Name: "a", Type: "uint256"}})
+	arg0, _ := NewType("uint256", nil)
+	arg1, _ := NewType("address", nil)
+	tuple, _ := NewType("tuple", []ArgumentMarshaling{{Name: "a", Type: "uint256"}})
 
 	expectedEvents := map[string]struct {
 		Anonymous bool
@@ -664,12 +600,12 @@ func TestBareEvents(t *testing.T) {
 		"balance": {false, nil},
 		"anon":    {true, nil},
 		"args": {false, []Argument{
-			{Name: "arg0", Type: Uint256, Indexed: false},
-			{Name: "arg1", Type: Address, Indexed: true},
+			{Name: "arg0", Type: arg0, Indexed: false},
+			{Name: "arg1", Type: arg1, Indexed: true},
 		}},
 		"tuple": {false, []Argument{
 			{Name: "t", Type: tuple, Indexed: false},
-			{Name: "arg1", Type: Address, Indexed: true},
+			{Name: "arg1", Type: arg1, Indexed: true},
 		}},
 	}
 
@@ -743,7 +679,7 @@ func TestUnpackEvent(t *testing.T) {
 	}
 	var ev ReceivedEvent
 
-	err = abi.UnpackIntoInterface(&ev, "received", data)
+	err = abi.Unpack(&ev, "received", data)
 	if err != nil {
 		t.Error(err)
 	}
@@ -752,215 +688,52 @@ func TestUnpackEvent(t *testing.T) {
 		Sender common.Address
 	}
 	var receivedAddrEv ReceivedAddrEvent
-	err = abi.UnpackIntoInterface(&receivedAddrEv, "receivedAddr", data)
+	err = abi.Unpack(&receivedAddrEv, "receivedAddr", data)
 	if err != nil {
 		t.Error(err)
 	}
 }
 
-func TestUnpackEventIntoMap(t *testing.T) {
-	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
-	abi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	const hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
-	data, err := hex.DecodeString(hexdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 == 0 {
-		t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
-	}
-
-	receivedMap := map[string]interface{}{}
-	expectedReceivedMap := map[string]interface{}{
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	if err := abi.UnpackIntoMap(receivedMap, "received", data); err != nil {
-		t.Error(err)
-	}
-	if len(receivedMap) != 3 {
-		t.Error("unpacked `received` map expected to have length 3")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-
-	receivedAddrMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(receivedAddrMap, "receivedAddr", data); err != nil {
-		t.Error(err)
-	}
-	if len(receivedAddrMap) != 1 {
-		t.Error("unpacked `receivedAddr` map expected to have length 1")
-	}
-	if receivedAddrMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked `receivedAddr` map does not match expected map")
-	}
-}
-
-func TestUnpackMethodIntoMap(t *testing.T) {
-	const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
-	abi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	const hexdata = `00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000015800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000158000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001580000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000015800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000158`
-	data, err := hex.DecodeString(hexdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 != 0 {
-		t.Errorf("len(data) is %d, want a multiple of 32", len(data))
-	}
-
-	// Tests a method with no outputs
-	receiveMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(receiveMap, "receive", data); err != nil {
-		t.Error(err)
-	}
-	if len(receiveMap) > 0 {
-		t.Error("unpacked `receive` map expected to have length 0")
-	}
-
-	// Tests a method with only outputs
-	sendMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(sendMap, "send", data); err != nil {
-		t.Error(err)
-	}
-	if len(sendMap) != 1 {
-		t.Error("unpacked `send` map expected to have length 1")
-	}
-	if sendMap["amount"].(*big.Int).Cmp(big.NewInt(1)) != 0 {
-		t.Error("unpacked `send` map expected `amount` value of 1")
-	}
-
-	// Tests a method with outputs and inputs
-	getMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(getMap, "get", data); err != nil {
-		t.Error(err)
-	}
-	if len(getMap) != 1 {
-		t.Error("unpacked `get` map expected to have length 1")
-	}
-	expectedBytes := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 88, 0}
-	if !bytes.Equal(getMap["hash"].([]byte), expectedBytes) {
-		t.Errorf("unpacked `get` map expected `hash` value of %v", expectedBytes)
-	}
-}
-
-func TestUnpackIntoMapNamingConflict(t *testing.T) {
-	// Two methods have the same name
-	var abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"get","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[],"name":"send","outputs":[{"name":"amount","type":"uint256"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"addr","type":"address"}],"name":"get","outputs":[{"name":"hash","type":"bytes"}],"payable":true,"stateMutability":"payable","type":"function"}]`
-	abi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var hexdata = `00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
-	data, err := hex.DecodeString(hexdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 == 0 {
-		t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
-	}
-	getMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(getMap, "get", data); err == nil {
-		t.Error("naming conflict between two methods; error expected")
-	}
-
-	// Two events have the same name
-	abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"received","type":"event"}]`
-	abi, err = JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158`
-	data, err = hex.DecodeString(hexdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 == 0 {
-		t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
-	}
-	receivedMap := map[string]interface{}{}
-	if err = abi.UnpackIntoMap(receivedMap, "received", data); err != nil {
-		t.Error("naming conflict between two events; no error expected")
-	}
-
-	// Method and event have the same name
-	abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"received","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
-	abi, err = JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 == 0 {
-		t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
-	}
-	if err = abi.UnpackIntoMap(receivedMap, "received", data); err == nil {
-		t.Error("naming conflict between an event and a method; error expected")
-	}
-
-	// Conflict is case sensitive
-	abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"received","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"}],"name":"receivedAddr","type":"event"}]`
-	abi, err = JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(data)%32 == 0 {
-		t.Errorf("len(data) is %d, want a non-multiple of 32", len(data))
-	}
-	expectedReceivedMap := map[string]interface{}{
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	if err = abi.UnpackIntoMap(receivedMap, "Received", data); err != nil {
-		t.Error(err)
-	}
-	if len(receivedMap) != 3 {
-		t.Error("unpacked `received` map expected to have length 3")
-	}
-	if receivedMap["sender"] != expectedReceivedMap["sender"] {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-	if receivedMap["amount"].(*big.Int).Cmp(expectedReceivedMap["amount"].(*big.Int)) != 0 {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-	if !bytes.Equal(receivedMap["memo"].([]byte), expectedReceivedMap["memo"].([]byte)) {
-		t.Error("unpacked `received` map does not match expected map")
-	}
-}
-
 func TestABI_MethodById(t *testing.T) {
-	abi, err := JSON(strings.NewReader(jsondata))
+	const abiJSON = `[
+		{"type":"function","name":"receive","constant":false,"inputs":[{"name":"memo","type":"bytes"}],"outputs":[],"payable":true,"stateMutability":"payable"},
+		{"type":"event","name":"received","anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}]},
+		{"type":"function","name":"fixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"}]},
+		{"type":"function","name":"fixedArrBytes","constant":true,"inputs":[{"name":"str","type":"bytes"},{"name":"fixedArr","type":"uint256[2]"}]},
+		{"type":"function","name":"mixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"}]},
+		{"type":"function","name":"doubleFixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"fixedArr2","type":"uint256[3]"}]},
+		{"type":"function","name":"multipleMixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"},{"name":"fixedArr2","type":"uint256[3]"}]},
+		{"type":"function","name":"balance","constant":true},
+		{"type":"function","name":"send","constant":false,"inputs":[{"name":"amount","type":"uint256"}]},
+		{"type":"function","name":"test","constant":false,"inputs":[{"name":"number","type":"uint32"}]},
+		{"type":"function","name":"string","constant":false,"inputs":[{"name":"inputs","type":"string"}]},
+		{"type":"function","name":"bool","constant":false,"inputs":[{"name":"inputs","type":"bool"}]},
+		{"type":"function","name":"address","constant":false,"inputs":[{"name":"inputs","type":"address"}]},
+		{"type":"function","name":"uint64[2]","constant":false,"inputs":[{"name":"inputs","type":"uint64[2]"}]},
+		{"type":"function","name":"uint64[]","constant":false,"inputs":[{"name":"inputs","type":"uint64[]"}]},
+		{"type":"function","name":"foo","constant":false,"inputs":[{"name":"inputs","type":"uint32"}]},
+		{"type":"function","name":"bar","constant":false,"inputs":[{"name":"inputs","type":"uint32"},{"name":"string","type":"uint16"}]},
+		{"type":"function","name":"_slice","constant":false,"inputs":[{"name":"inputs","type":"uint32[2]"}]},
+		{"type":"function","name":"__slice256","constant":false,"inputs":[{"name":"inputs","type":"uint256[2]"}]},
+		{"type":"function","name":"sliceAddress","constant":false,"inputs":[{"name":"inputs","type":"address[]"}]},
+		{"type":"function","name":"sliceMultiAddress","constant":false,"inputs":[{"name":"a","type":"address[]"},{"name":"b","type":"address[]"}]}
+	]
+`
+	abi, err := JSON(strings.NewReader(abiJSON))
 	if err != nil {
 		t.Fatal(err)
 	}
 	for name, m := range abi.Methods {
 		a := fmt.Sprintf("%v", m)
-		m2, err := abi.MethodById(m.ID)
+		m2, err := abi.MethodById(m.Id())
 		if err != nil {
 			t.Fatalf("Failed to look up ABI method: %v", err)
 		}
 		b := fmt.Sprintf("%v", m2)
 		if a != b {
-			t.Errorf("Method %v (id %x) not 'findable' by id in ABI", name, m.ID)
+			t.Errorf("Method %v (id %v) not 'findable' by id in ABI", name, common.ToHex(m.Id()))
 		}
 	}
-	// test unsuccessful lookups
-	if _, err = abi.MethodById(crypto.Keccak256()); err == nil {
-		t.Error("Expected error: no method with this id")
-	}
 	// Also test empty
 	if _, err := abi.MethodById([]byte{0x00}); err == nil {
 		t.Errorf("Expected error, too short to decode data")
@@ -972,177 +745,3 @@ func TestABI_MethodById(t *testing.T) {
 		t.Errorf("Expected error, nil is short to decode data")
 	}
 }
-
-func TestABI_EventById(t *testing.T) {
-	tests := []struct {
-		name  string
-		json  string
-		event string
-	}{
-		{
-			name: "",
-			json: `[
-			{"type":"event","name":"received","anonymous":false,"inputs":[
-				{"indexed":false,"name":"sender","type":"address"},
-				{"indexed":false,"name":"amount","type":"uint256"},
-				{"indexed":false,"name":"memo","type":"bytes"}
-				]
-			}]`,
-			event: "received(address,uint256,bytes)",
-		}, {
-			name: "",
-			json: `[
-				{ "constant": true, "inputs": [], "name": "name", "outputs": [ { "name": "", "type": "string" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "constant": false, "inputs": [ { "name": "_spender", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "approve", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
-				{ "constant": true, "inputs": [], "name": "totalSupply", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "constant": false, "inputs": [ { "name": "_from", "type": "address" }, { "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "transferFrom", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
-				{ "constant": true, "inputs": [], "name": "decimals", "outputs": [ { "name": "", "type": "uint8" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "constant": true, "inputs": [ { "name": "_owner", "type": "address" } ], "name": "balanceOf", "outputs": [ { "name": "balance", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "constant": true, "inputs": [], "name": "symbol", "outputs": [ { "name": "", "type": "string" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "constant": false, "inputs": [ { "name": "_to", "type": "address" }, { "name": "_value", "type": "uint256" } ], "name": "transfer", "outputs": [ { "name": "", "type": "bool" } ], "payable": false, "stateMutability": "nonpayable", "type": "function" },
-				{ "constant": true, "inputs": [ { "name": "_owner", "type": "address" }, { "name": "_spender", "type": "address" } ], "name": "allowance", "outputs": [ { "name": "", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" },
-				{ "payable": true, "stateMutability": "payable", "type": "fallback" },
-				{ "anonymous": false, "inputs": [ { "indexed": true, "name": "owner", "type": "address" }, { "indexed": true, "name": "spender", "type": "address" }, { "indexed": false, "name": "value", "type": "uint256" } ], "name": "Approval", "type": "event" },
-				{ "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" }
-			]`,
-			event: "Transfer(address,address,uint256)",
-		},
-	}
-
-	for testnum, test := range tests {
-		abi, err := JSON(strings.NewReader(test.json))
-		if err != nil {
-			t.Error(err)
-		}
-
-		topic := test.event
-		topicID := crypto.Keccak256Hash([]byte(topic))
-
-		event, err := abi.EventByID(topicID)
-		if err != nil {
-			t.Fatalf("Failed to look up ABI method: %v, test #%d", err, testnum)
-		}
-		if event == nil {
-			t.Errorf("We should find a event for topic %s, test #%d", topicID.Hex(), testnum)
-		}
-
-		if event.ID != topicID {
-			t.Errorf("Event id %s does not match topic %s, test #%d", event.ID.Hex(), topicID.Hex(), testnum)
-		}
-
-		unknowntopicID := crypto.Keccak256Hash([]byte("unknownEvent"))
-		unknownEvent, err := abi.EventByID(unknowntopicID)
-		if err == nil {
-			t.Errorf("EventByID should return an error if a topic is not found, test #%d", testnum)
-		}
-		if unknownEvent != nil {
-			t.Errorf("We should not find any event for topic %s, test #%d", unknowntopicID.Hex(), testnum)
-		}
-	}
-}
-
-// TestDoubleDuplicateMethodNames checks that if transfer0 already exists, there won't be a name
-// conflict and that the second transfer method will be renamed transfer1.
-func TestDoubleDuplicateMethodNames(t *testing.T) {
-	abiJSON := `[{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"}],"name":"transfer0","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"},{"name":"data","type":"bytes"},{"name":"customFallback","type":"string"}],"name":"transfer","outputs":[{"name":"ok","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`
-	contractAbi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := contractAbi.Methods["transfer"]; !ok {
-		t.Fatalf("Could not find original method")
-	}
-	if _, ok := contractAbi.Methods["transfer0"]; !ok {
-		t.Fatalf("Could not find duplicate method")
-	}
-	if _, ok := contractAbi.Methods["transfer1"]; !ok {
-		t.Fatalf("Could not find duplicate method")
-	}
-	if _, ok := contractAbi.Methods["transfer2"]; ok {
-		t.Fatalf("Should not have found extra method")
-	}
-}
-
-// TestDoubleDuplicateEventNames checks that if send0 already exists, there won't be a name
-// conflict and that the second send event will be renamed send1.
-// The test runs the abi of the following contract.
-// 	contract DuplicateEvent {
-// 		event send(uint256 a);
-//		event send0();
-//		event send();
-//	}
-func TestDoubleDuplicateEventNames(t *testing.T) {
-	abiJSON := `[{"anonymous": false,"inputs": [{"indexed": false,"internalType": "uint256","name": "a","type": "uint256"}],"name": "send","type": "event"},{"anonymous": false,"inputs": [],"name": "send0","type": "event"},{	"anonymous": false,	"inputs": [],"name": "send","type": "event"}]`
-	contractAbi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, ok := contractAbi.Events["send"]; !ok {
-		t.Fatalf("Could not find original event")
-	}
-	if _, ok := contractAbi.Events["send0"]; !ok {
-		t.Fatalf("Could not find duplicate event")
-	}
-	if _, ok := contractAbi.Events["send1"]; !ok {
-		t.Fatalf("Could not find duplicate event")
-	}
-	if _, ok := contractAbi.Events["send2"]; ok {
-		t.Fatalf("Should not have found extra event")
-	}
-}
-
-// TestUnnamedEventParam checks that an event with unnamed parameters is
-// correctly handled.
-// The test runs the abi of the following contract.
-// 	contract TestEvent {
-//		event send(uint256, uint256);
-//	}
-func TestUnnamedEventParam(t *testing.T) {
-	abiJSON := `[{ "anonymous": false, "inputs": [{	"indexed": false,"internalType": "uint256",	"name": "","type": "uint256"},{"indexed": false,"internalType": "uint256","name": "","type": "uint256"}],"name": "send","type": "event"}]`
-	contractAbi, err := JSON(strings.NewReader(abiJSON))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	event, ok := contractAbi.Events["send"]
-	if !ok {
-		t.Fatalf("Could not find event")
-	}
-	if event.Inputs[0].Name != "arg0" {
-		t.Fatalf("Could not find input")
-	}
-	if event.Inputs[1].Name != "arg1" {
-		t.Fatalf("Could not find input")
-	}
-}
-
-func TestUnpackRevert(t *testing.T) {
-	t.Parallel()
-
-	var cases = []struct {
-		input     string
-		expect    string
-		expectErr error
-	}{
-		{"", "", errors.New("invalid data for unpacking")},
-		{"08c379a1", "", errors.New("invalid data for unpacking")},
-		{"08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d72657665727420726561736f6e00000000000000000000000000000000000000", "revert reason", nil},
-	}
-	for index, c := range cases {
-		t.Run(fmt.Sprintf("case %d", index), func(t *testing.T) {
-			got, err := UnpackRevert(common.Hex2Bytes(c.input))
-			if c.expectErr != nil {
-				if err == nil {
-					t.Fatalf("Expected non-nil error")
-				}
-				if err.Error() != c.expectErr.Error() {
-					t.Fatalf("Expected error mismatch, want %v, got %v", c.expectErr, err)
-				}
-				return
-			}
-			if c.expect != got {
-				t.Fatalf("Output mismatch, want %v, got %v", c.expect, got)
-			}
-		})
-	}
-}

accounts/abi/argument.go

@@ -36,12 +36,11 @@ type Arguments []Argument
 type ArgumentMarshaling struct {
 	Name       string
 	Type       string
-	InternalType string
 	Components []ArgumentMarshaling
 	Indexed    bool
 }
 
-// UnmarshalJSON implements json.Unmarshaler interface.
+// UnmarshalJSON implements json.Unmarshaler interface
 func (argument *Argument) UnmarshalJSON(data []byte) error {
 	var arg ArgumentMarshaling
 	err := json.Unmarshal(data, &arg)
@@ -49,7 +48,7 @@ func (argument *Argument) UnmarshalJSON(data []byte) error {
 		return fmt.Errorf("argument json err: %v", err)
 	}
 
-	argument.Type, err = NewType(arg.Type, arg.InternalType, arg.Components)
+	argument.Type, err = NewType(arg.Type, arg.Components)
 	if err != nil {
 		return err
 	}
@@ -59,7 +58,19 @@ func (argument *Argument) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
-// NonIndexed returns the arguments with indexed arguments filtered out.
+// LengthNonIndexed returns the number of arguments when not counting 'indexed' ones. Only events
+// can ever have 'indexed' arguments, it should always be false on arguments for method input/output
+func (arguments Arguments) LengthNonIndexed() int {
+	out := 0
+	for _, arg := range arguments {
+		if !arg.Indexed {
+			out++
+		}
+	}
+	return out
+}
+
+// NonIndexed returns the arguments with indexed arguments filtered out
 func (arguments Arguments) NonIndexed() Arguments {
 	var ret []Argument
 	for _, arg := range arguments {
@@ -70,127 +81,169 @@ func (arguments Arguments) NonIndexed() Arguments {
 	return ret
 }
 
-// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[].
+// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[]
 func (arguments Arguments) isTuple() bool {
 	return len(arguments) > 1
 }
 
-// Unpack performs the operation hexdata -> Go format.
-func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
-	if len(data) == 0 {
-		if len(arguments) != 0 {
-			return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
-		}
-		// Nothing to unmarshal, return default variables
-		nonIndexedArgs := arguments.NonIndexed()
-		defaultVars := make([]interface{}, len(nonIndexedArgs))
-		for index, arg := range nonIndexedArgs {
-			defaultVars[index] = reflect.New(arg.Type.GetType())
-		}
-		return defaultVars, nil
-	}
-	return arguments.UnpackValues(data)
-}
-
-// UnpackIntoMap performs the operation hexdata -> mapping of argument name to argument value.
-func (arguments Arguments) UnpackIntoMap(v map[string]interface{}, data []byte) error {
-	// Make sure map is not nil
-	if v == nil {
-		return fmt.Errorf("abi: cannot unpack into a nil map")
-	}
-	if len(data) == 0 {
-		if len(arguments) != 0 {
-			return fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
-		}
-		return nil // Nothing to unmarshal, return
+// Unpack performs the operation hexdata -> Go format
+func (arguments Arguments) Unpack(v interface{}, data []byte) error {
+	// make sure the passed value is arguments pointer
+	if reflect.Ptr != reflect.ValueOf(v).Kind() {
+		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
 	}
 	marshalledValues, err := arguments.UnpackValues(data)
 	if err != nil {
 		return err
 	}
-	for i, arg := range arguments.NonIndexed() {
-		v[arg.Name] = marshalledValues[i]
+	if arguments.isTuple() {
+		return arguments.unpackTuple(v, marshalledValues)
+	}
+	return arguments.unpackAtomic(v, marshalledValues[0])
+}
+
+// unpack sets the unmarshalled value to go format.
+// Note the dst here must be settable.
+func unpack(t *Type, dst interface{}, src interface{}) error {
+	var (
+		dstVal = reflect.ValueOf(dst).Elem()
+		srcVal = reflect.ValueOf(src)
+	)
+
+	if t.T != TupleTy && !((t.T == SliceTy || t.T == ArrayTy) && t.Elem.T == TupleTy) {
+		return set(dstVal, srcVal)
+	}
+
+	switch t.T {
+	case TupleTy:
+		if dstVal.Kind() != reflect.Struct {
+			return fmt.Errorf("abi: invalid dst value for unpack, want struct, got %s", dstVal.Kind())
+		}
+		fieldmap, err := mapArgNamesToStructFields(t.TupleRawNames, dstVal)
+		if err != nil {
+			return err
+		}
+		for i, elem := range t.TupleElems {
+			fname := fieldmap[t.TupleRawNames[i]]
+			field := dstVal.FieldByName(fname)
+			if !field.IsValid() {
+				return fmt.Errorf("abi: field %s can't found in the given value", t.TupleRawNames[i])
+			}
+			if err := unpack(elem, field.Addr().Interface(), srcVal.Field(i).Interface()); err != nil {
+				return err
+			}
+		}
+		return nil
+	case SliceTy:
+		if dstVal.Kind() != reflect.Slice {
+			return fmt.Errorf("abi: invalid dst value for unpack, want slice, got %s", dstVal.Kind())
+		}
+		slice := reflect.MakeSlice(dstVal.Type(), srcVal.Len(), srcVal.Len())
+		for i := 0; i < slice.Len(); i++ {
+			if err := unpack(t.Elem, slice.Index(i).Addr().Interface(), srcVal.Index(i).Interface()); err != nil {
+				return err
+			}
+		}
+		dstVal.Set(slice)
+	case ArrayTy:
+		if dstVal.Kind() != reflect.Array {
+			return fmt.Errorf("abi: invalid dst value for unpack, want array, got %s", dstVal.Kind())
+		}
+		array := reflect.New(dstVal.Type()).Elem()
+		for i := 0; i < array.Len(); i++ {
+			if err := unpack(t.Elem, array.Index(i).Addr().Interface(), srcVal.Index(i).Interface()); err != nil {
+				return err
+			}
+		}
+		dstVal.Set(array)
 	}
 	return nil
 }
 
-// Copy performs the operation go format -> provided struct.
-func (arguments Arguments) Copy(v interface{}, values []interface{}) error {
-	// make sure the passed value is arguments pointer
-	if reflect.Ptr != reflect.ValueOf(v).Kind() {
-		return fmt.Errorf("abi: Unpack(non-pointer %T)", v)
-	}
-	if len(values) == 0 {
-		if len(arguments) != 0 {
-			return fmt.Errorf("abi: attempting to copy no values while %d arguments are expected", len(arguments))
-		}
-		return nil // Nothing to copy, return
-	}
-	if arguments.isTuple() {
-		return arguments.copyTuple(v, values)
-	}
-	return arguments.copyAtomic(v, values[0])
-}
-
 // unpackAtomic unpacks ( hexdata -> go ) a single value
-func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{}) error {
-	dst := reflect.ValueOf(v).Elem()
-	src := reflect.ValueOf(marshalledValues)
-
-	if dst.Kind() == reflect.Struct && src.Kind() != reflect.Struct {
-		return set(dst.Field(0), src)
+func (arguments Arguments) unpackAtomic(v interface{}, marshalledValues interface{}) error {
+	if arguments.LengthNonIndexed() == 0 {
+		return nil
 	}
-	return set(dst, src)
-}
+	argument := arguments.NonIndexed()[0]
+	elem := reflect.ValueOf(v).Elem()
 
-// copyTuple copies a batch of values from marshalledValues to v.
-func (arguments Arguments) copyTuple(v interface{}, marshalledValues []interface{}) error {
-	value := reflect.ValueOf(v).Elem()
-	nonIndexedArgs := arguments.NonIndexed()
-
-	switch value.Kind() {
-	case reflect.Struct:
-		argNames := make([]string, len(nonIndexedArgs))
-		for i, arg := range nonIndexedArgs {
-			argNames[i] = arg.Name
-		}
-		var err error
-		abi2struct, err := mapArgNamesToStructFields(argNames, value)
+	if elem.Kind() == reflect.Struct {
+		fieldmap, err := mapArgNamesToStructFields([]string{argument.Name}, elem)
 		if err != nil {
 			return err
 		}
-		for i, arg := range nonIndexedArgs {
+		field := elem.FieldByName(fieldmap[argument.Name])
+		if !field.IsValid() {
+			return fmt.Errorf("abi: field %s can't be found in the given value", argument.Name)
+		}
+		return unpack(&argument.Type, field.Addr().Interface(), marshalledValues)
+	}
+	return unpack(&argument.Type, elem.Addr().Interface(), marshalledValues)
+}
+
+// unpackTuple unpacks ( hexdata -> go ) a batch of values.
+func (arguments Arguments) unpackTuple(v interface{}, marshalledValues []interface{}) error {
+	var (
+		value = reflect.ValueOf(v).Elem()
+		typ   = value.Type()
+		kind  = value.Kind()
+	)
+	if err := requireUnpackKind(value, typ, kind, arguments); err != nil {
+		return err
+	}
+
+	// If the interface is a struct, get of abi->struct_field mapping
+	var abi2struct map[string]string
+	if kind == reflect.Struct {
+		var (
+			argNames []string
+			err      error
+		)
+		for _, arg := range arguments.NonIndexed() {
+			argNames = append(argNames, arg.Name)
+		}
+		abi2struct, err = mapArgNamesToStructFields(argNames, value)
+		if err != nil {
+			return err
+		}
+	}
+	for i, arg := range arguments.NonIndexed() {
+		switch kind {
+		case reflect.Struct:
 			field := value.FieldByName(abi2struct[arg.Name])
 			if !field.IsValid() {
 				return fmt.Errorf("abi: field %s can't be found in the given value", arg.Name)
 			}
-			if err := set(field, reflect.ValueOf(marshalledValues[i])); err != nil {
+			if err := unpack(&arg.Type, field.Addr().Interface(), marshalledValues[i]); err != nil {
 				return err
 			}
-		}
 		case reflect.Slice, reflect.Array:
-		if value.Len() < len(marshalledValues) {
+			if value.Len() < i {
 				return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len())
 			}
-		for i := range nonIndexedArgs {
-			if err := set(value.Index(i), reflect.ValueOf(marshalledValues[i])); err != nil {
+			v := value.Index(i)
+			if err := requireAssignable(v, reflect.ValueOf(marshalledValues[i])); err != nil {
 				return err
 			}
+			if err := unpack(&arg.Type, v.Addr().Interface(), marshalledValues[i]); err != nil {
+				return err
 			}
 		default:
-		return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", value.Type())
+			return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", typ)
+		}
 	}
 	return nil
+
 }
 
 // UnpackValues can be used to unpack ABI-encoded hexdata according to the ABI-specification,
 // without supplying a struct to unpack into. Instead, this method returns a list containing the
 // values. An atomic argument will be a list with one element.
 func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
-	nonIndexedArgs := arguments.NonIndexed()
-	retval := make([]interface{}, 0, len(nonIndexedArgs))
+	retval := make([]interface{}, 0, arguments.LengthNonIndexed())
 	virtualArgs := 0
-	for index, arg := range nonIndexedArgs {
+	for index, arg := range arguments.NonIndexed() {
 		marshalledValue, err := toGoType((index+virtualArgs)*32, arg.Type, data)
 		if arg.Type.T == ArrayTy && !isDynamicType(arg.Type) {
 			// If we have a static array, like [3]uint256, these are coded as
@@ -217,18 +270,18 @@ func (arguments Arguments) UnpackValues(data []byte) ([]interface{}, error) {
 	return retval, nil
 }
 
-// PackValues performs the operation Go format -> Hexdata.
-// It is the semantic opposite of UnpackValues.
+// PackValues performs the operation Go format -> Hexdata
+// It is the semantic opposite of UnpackValues
 func (arguments Arguments) PackValues(args []interface{}) ([]byte, error) {
 	return arguments.Pack(args...)
 }
 
-// Pack performs the operation Go format -> Hexdata.
+// Pack performs the operation Go format -> Hexdata
 func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) {
 	// Make sure arguments match up and pack them
 	abiArgs := arguments
 	if len(args) != len(abiArgs) {
-		return nil, fmt.Errorf("argument count mismatch: got %d for %d", len(args), len(abiArgs))
+		return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs))
 	}
 	// variable input is the output appended at the end of packed
 	// output. This is used for strings and bytes types input.

accounts/abi/bind/auth.go

@@ -21,29 +21,16 @@ import (
 	"errors"
 	"io"
 	"io/ioutil"
-	"math/big"
 
-	"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"
-	"github.com/ethereum/go-ethereum/log"
 )
 
-// ErrNoChainID is returned whenever the user failed to specify a chain id.
-var ErrNoChainID = errors.New("no chain id specified")
-
-// ErrNotAuthorized is returned when an account is not properly unlocked.
-var ErrNotAuthorized = errors.New("not authorized to sign this account")
-
 // NewTransactor is a utility method to easily create a transaction signer from
 // an encrypted json key stream and the associated passphrase.
-//
-// Deprecated: Use NewTransactorWithChainID instead.
 func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
-	log.Warn("WARNING: NewTransactor has been deprecated in favour of NewTransactorWithChainID")
 	json, err := ioutil.ReadAll(keyin)
 	if err != nil {
 		return nil, err
@@ -55,41 +42,15 @@ func NewTransactor(keyin io.Reader, passphrase string) (*TransactOpts, error) {
 	return NewKeyedTransactor(key.PrivateKey), nil
 }
 
-// NewKeyStoreTransactor is a utility method to easily create a transaction signer from
-// an decrypted key from a keystore.
-//
-// Deprecated: Use NewKeyStoreTransactorWithChainID instead.
-func NewKeyStoreTransactor(keystore *keystore.KeyStore, account accounts.Account) (*TransactOpts, error) {
-	log.Warn("WARNING: NewKeyStoreTransactor has been deprecated in favour of NewTransactorWithChainID")
-	signer := types.HomesteadSigner{}
-	return &TransactOpts{
-		From: account.Address,
-		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
-			if address != account.Address {
-				return nil, ErrNotAuthorized
-			}
-			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.
-//
-// Deprecated: Use NewKeyedTransactorWithChainID instead.
 func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
-	log.Warn("WARNING: NewKeyedTransactor has been deprecated in favour of NewKeyedTransactorWithChainID")
 	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
-	signer := types.HomesteadSigner{}
 	return &TransactOpts{
 		From: keyAddr,
-		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
+		Signer: func(signer types.Signer, address common.Address, tx *types.Transaction) (*types.Transaction, error) {
 			if address != keyAddr {
-				return nil, ErrNotAuthorized
+				return nil, errors.New("not authorized to sign this account")
 			}
 			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
 			if err != nil {
@@ -99,76 +60,3 @@ func NewKeyedTransactor(key *ecdsa.PrivateKey) *TransactOpts {
 		},
 	}
 }
-
-// NewTransactorWithChainID is a utility method to easily create a transaction signer from
-// an encrypted json key stream and the associated passphrase.
-func NewTransactorWithChainID(keyin io.Reader, passphrase string, chainID *big.Int) (*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 NewKeyedTransactorWithChainID(key.PrivateKey, chainID)
-}
-
-// NewKeyStoreTransactorWithChainID is a utility method to easily create a transaction signer from
-// an decrypted key from a keystore.
-func NewKeyStoreTransactorWithChainID(keystore *keystore.KeyStore, account accounts.Account, chainID *big.Int) (*TransactOpts, error) {
-	if chainID == nil {
-		return nil, ErrNoChainID
-	}
-	signer := types.LatestSignerForChainID(chainID)
-	return &TransactOpts{
-		From: account.Address,
-		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
-			if address != account.Address {
-				return nil, ErrNotAuthorized
-			}
-			signature, err := keystore.SignHash(account, signer.Hash(tx).Bytes())
-			if err != nil {
-				return nil, err
-			}
-			return tx.WithSignature(signer, signature)
-		},
-	}, nil
-}
-
-// NewKeyedTransactorWithChainID is a utility method to easily create a transaction signer
-// from a single private key.
-func NewKeyedTransactorWithChainID(key *ecdsa.PrivateKey, chainID *big.Int) (*TransactOpts, error) {
-	keyAddr := crypto.PubkeyToAddress(key.PublicKey)
-	if chainID == nil {
-		return nil, ErrNoChainID
-	}
-	signer := types.LatestSignerForChainID(chainID)
-	return &TransactOpts{
-		From: keyAddr,
-		Signer: func(address common.Address, tx *types.Transaction) (*types.Transaction, error) {
-			if address != keyAddr {
-				return nil, ErrNotAuthorized
-			}
-			signature, err := crypto.Sign(signer.Hash(tx).Bytes(), key)
-			if err != nil {
-				return nil, err
-			}
-			return tx.WithSignature(signer, signature)
-		},
-	}, nil
-}
-
-// 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(address common.Address, transaction *types.Transaction) (*types.Transaction, error) {
-			if address != account.Address {
-				return nil, ErrNotAuthorized
-			}
-			return clef.SignTx(account, transaction, nil) // Clef enforces its own chain id
-		},
-	}
-}

accounts/abi/bind/backend.go

@@ -41,7 +41,7 @@ var (
 	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
 )
 
-// ContractCaller defines the methods needed to allow operating with a contract on a read
+// ContractCaller defines the methods needed to allow operating with contract on a read
 // only basis.
 type ContractCaller interface {
 	// CodeAt returns the code of the given account. This is needed to differentiate
@@ -62,8 +62,8 @@ type PendingContractCaller interface {
 	PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error)
 }
 
-// ContractTransactor defines the methods needed to allow operating with a contract
-// on a write only basis. Besides the transacting method, the remainder are helpers
+// ContractTransactor defines the methods needed to allow operating with contract
+// on a write only basis. Beside the transacting method, the remainder are helpers
 // used when the user does not provide some needed values, but rather leaves it up
 // to the transactor to decide.
 type ContractTransactor interface {

accounts/abi/bind/backends/simulated.go

@@ -25,10 +25,8 @@ import (
 	"time"
 
 	"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/common/math"
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/core"
@@ -40,69 +38,49 @@ import (
 	"github.com/ethereum/go-ethereum/eth/filters"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-// This nil assignment ensures at compile time that SimulatedBackend implements bind.ContractBackend.
+// This nil assignment ensures compile time that SimulatedBackend implements bind.ContractBackend.
 var _ bind.ContractBackend = (*SimulatedBackend)(nil)
 
-var (
-	errBlockNumberUnsupported  = errors.New("simulatedBackend cannot access blocks other than the latest block")
-	errBlockDoesNotExist       = errors.New("block does not exist in blockchain")
-	errTransactionDoesNotExist = errors.New("transaction does not exist")
-)
+var errBlockNumberUnsupported = errors.New("SimulatedBackend cannot access blocks other than the latest block")
+var errGasEstimationFailed = errors.New("gas required exceeds allowance or always failing transaction")
 
 // SimulatedBackend implements bind.ContractBackend, simulating a blockchain in
-// the background. Its main purpose is to allow for easy testing of contract bindings.
-// Simulated backend implements the following interfaces:
-// ChainReader, ChainStateReader, ContractBackend, ContractCaller, ContractFilterer, ContractTransactor,
-// DeployBackend, GasEstimator, GasPricer, LogFilterer, PendingContractCaller, TransactionReader, and TransactionSender
+// the background. Its main purpose is to allow easily testing contract bindings.
 type SimulatedBackend struct {
 	database   ethdb.Database   // In memory database to store our testing data
 	blockchain *core.BlockChain // Ethereum blockchain to handle the consensus
 
 	mu           sync.Mutex
 	pendingBlock *types.Block   // Currently pending block that will be imported on request
-	pendingState *state.StateDB // Currently pending state that will be the active on request
+	pendingState *state.StateDB // Currently pending state that will be the active on on request
 
 	events *filters.EventSystem // Event system for filtering log events live
 
 	config *params.ChainConfig
 }
 
-// NewSimulatedBackendWithDatabase creates a new binding backend based on the given database
-// and uses a simulated blockchain for testing purposes.
-// A simulated backend always uses chainID 1337.
-func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+// NewSimulatedBackend creates a new binding backend using a simulated blockchain
+// for testing purposes.
+func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
+	database := ethdb.NewMemDatabase()
 	genesis := core.Genesis{Config: params.AllEthashProtocolChanges, GasLimit: gasLimit, Alloc: alloc}
 	genesis.MustCommit(database)
-	blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil, nil)
+	blockchain, _ := core.NewBlockChain(database, nil, genesis.Config, ethash.NewFaker(), vm.Config{}, nil)
 
 	backend := &SimulatedBackend{
 		database:   database,
 		blockchain: blockchain,
 		config:     genesis.Config,
-		events:     filters.NewEventSystem(&filterBackend{database, blockchain}, false),
+		events:     filters.NewEventSystem(new(event.TypeMux), &filterBackend{database, blockchain}, false),
 	}
 	backend.rollback()
 	return backend
 }
 
-// NewSimulatedBackend creates a new binding backend using a simulated blockchain
-// for testing purposes.
-// A simulated backend always uses chainID 1337.
-func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend {
-	return NewSimulatedBackendWithDatabase(rawdb.NewMemoryDatabase(), alloc, gasLimit)
-}
-
-// Close terminates the underlying blockchain's update loop.
-func (b *SimulatedBackend) Close() error {
-	b.blockchain.Stop()
-	return nil
-}
-
 // Commit imports all the pending transactions as a single block and starts a
 // fresh new state.
 func (b *SimulatedBackend) Commit() {
@@ -125,21 +103,10 @@ func (b *SimulatedBackend) Rollback() {
 
 func (b *SimulatedBackend) rollback() {
 	blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {})
+	statedb, _ := b.blockchain.State()
 
 	b.pendingBlock = blocks[0]
-	b.pendingState, _ = state.New(b.pendingBlock.Root(), b.blockchain.StateCache(), nil)
-}
-
-// stateByBlockNumber retrieves a state by a given blocknumber.
-func (b *SimulatedBackend) stateByBlockNumber(ctx context.Context, blockNumber *big.Int) (*state.StateDB, error) {
-	if blockNumber == nil || blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) == 0 {
-		return b.blockchain.State()
-	}
-	block, err := b.blockByNumberNoLock(ctx, blockNumber)
-	if err != nil {
-		return nil, err
-	}
-	return b.blockchain.StateAt(block.Root())
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database())
 }
 
 // CodeAt returns the code associated with a certain account in the blockchain.
@@ -147,12 +114,11 @@ func (b *SimulatedBackend) CodeAt(ctx context.Context, contract common.Address,
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
-	if err != nil {
-		return nil, err
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return nil, errBlockNumberUnsupported
 	}
-
-	return stateDB.GetCode(contract), nil
+	statedb, _ := b.blockchain.State()
+	return statedb.GetCode(contract), nil
 }
 
 // BalanceAt returns the wei balance of a certain account in the blockchain.
@@ -160,12 +126,11 @@ func (b *SimulatedBackend) BalanceAt(ctx context.Context, contract common.Addres
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
-	if err != nil {
-		return nil, err
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return nil, errBlockNumberUnsupported
 	}
-
-	return stateDB.GetBalance(contract), nil
+	statedb, _ := b.blockchain.State()
+	return statedb.GetBalance(contract), nil
 }
 
 // NonceAt returns the nonce of a certain account in the blockchain.
@@ -173,12 +138,11 @@ func (b *SimulatedBackend) NonceAt(ctx context.Context, contract common.Address,
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
-	if err != nil {
-		return 0, err
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return 0, errBlockNumberUnsupported
 	}
-
-	return stateDB.GetNonce(contract), nil
+	statedb, _ := b.blockchain.State()
+	return statedb.GetNonce(contract), nil
 }
 
 // StorageAt returns the value of key in the storage of an account in the blockchain.
@@ -186,158 +150,20 @@ func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Addres
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	stateDB, err := b.stateByBlockNumber(ctx, blockNumber)
-	if err != nil {
-		return nil, err
+	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
+		return nil, errBlockNumberUnsupported
 	}
-
-	val := stateDB.GetState(contract, key)
+	statedb, _ := b.blockchain.State()
+	val := statedb.GetState(contract, key)
 	return val[:], nil
 }
 
 // TransactionReceipt returns the receipt of a transaction.
 func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash, b.config)
+	receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash)
 	return receipt, nil
 }
 
-// TransactionByHash checks the pool of pending transactions in addition to the
-// blockchain. The isPending return value indicates whether the transaction has been
-// mined yet. Note that the transaction may not be part of the canonical chain even if
-// it's not pending.
-func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	tx := b.pendingBlock.Transaction(txHash)
-	if tx != nil {
-		return tx, true, nil
-	}
-	tx, _, _, _ = rawdb.ReadTransaction(b.database, txHash)
-	if tx != nil {
-		return tx, false, nil
-	}
-	return nil, false, ethereum.NotFound
-}
-
-// BlockByHash retrieves a block based on the block hash.
-func (b *SimulatedBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if hash == b.pendingBlock.Hash() {
-		return b.pendingBlock, nil
-	}
-
-	block := b.blockchain.GetBlockByHash(hash)
-	if block != nil {
-		return block, nil
-	}
-
-	return nil, errBlockDoesNotExist
-}
-
-// BlockByNumber retrieves a block from the database by number, caching it
-// (associated with its hash) if found.
-func (b *SimulatedBackend) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	return b.blockByNumberNoLock(ctx, number)
-}
-
-// blockByNumberNoLock retrieves a block from the database by number, caching it
-// (associated with its hash) if found without Lock.
-func (b *SimulatedBackend) blockByNumberNoLock(ctx context.Context, number *big.Int) (*types.Block, error) {
-	if number == nil || number.Cmp(b.pendingBlock.Number()) == 0 {
-		return b.blockchain.CurrentBlock(), nil
-	}
-
-	block := b.blockchain.GetBlockByNumber(uint64(number.Int64()))
-	if block == nil {
-		return nil, errBlockDoesNotExist
-	}
-
-	return block, nil
-}
-
-// HeaderByHash returns a block header from the current canonical chain.
-func (b *SimulatedBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if hash == b.pendingBlock.Hash() {
-		return b.pendingBlock.Header(), nil
-	}
-
-	header := b.blockchain.GetHeaderByHash(hash)
-	if header == nil {
-		return nil, errBlockDoesNotExist
-	}
-
-	return header, nil
-}
-
-// HeaderByNumber returns a block header from the current canonical chain. If number is
-// nil, the latest known header is returned.
-func (b *SimulatedBackend) HeaderByNumber(ctx context.Context, block *big.Int) (*types.Header, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if block == nil || block.Cmp(b.pendingBlock.Number()) == 0 {
-		return b.blockchain.CurrentHeader(), nil
-	}
-
-	return b.blockchain.GetHeaderByNumber(uint64(block.Int64())), nil
-}
-
-// TransactionCount returns the number of transactions in a given block.
-func (b *SimulatedBackend) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if blockHash == b.pendingBlock.Hash() {
-		return uint(b.pendingBlock.Transactions().Len()), nil
-	}
-
-	block := b.blockchain.GetBlockByHash(blockHash)
-	if block == nil {
-		return uint(0), errBlockDoesNotExist
-	}
-
-	return uint(block.Transactions().Len()), nil
-}
-
-// TransactionInBlock returns the transaction for a specific block at a specific index.
-func (b *SimulatedBackend) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if blockHash == b.pendingBlock.Hash() {
-		transactions := b.pendingBlock.Transactions()
-		if uint(len(transactions)) < index+1 {
-			return nil, errTransactionDoesNotExist
-		}
-
-		return transactions[index], nil
-	}
-
-	block := b.blockchain.GetBlockByHash(blockHash)
-	if block == nil {
-		return nil, errBlockDoesNotExist
-	}
-
-	transactions := block.Transactions()
-	if uint(len(transactions)) < index+1 {
-		return nil, errTransactionDoesNotExist
-	}
-
-	return transactions[index], nil
-}
-
 // PendingCodeAt returns the code associated with an account in the pending state.
 func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
 	b.mu.Lock()
@@ -346,36 +172,6 @@ func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Ad
 	return b.pendingState.GetCode(contract), nil
 }
 
-func newRevertError(result *core.ExecutionResult) *revertError {
-	reason, errUnpack := abi.UnpackRevert(result.Revert())
-	err := errors.New("execution reverted")
-	if errUnpack == nil {
-		err = fmt.Errorf("execution reverted: %v", reason)
-	}
-	return &revertError{
-		error:  err,
-		reason: hexutil.Encode(result.Revert()),
-	}
-}
-
-// revertError is an API error that encompasses an EVM revert with JSON error
-// code and a binary data blob.
-type revertError struct {
-	error
-	reason string // revert reason hex encoded
-}
-
-// ErrorCode returns the JSON error code for a revert.
-// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal
-func (e *revertError) ErrorCode() int {
-	return 3
-}
-
-// ErrorData returns the hex encoded revert reason.
-func (e *revertError) ErrorData() interface{} {
-	return e.reason
-}
-
 // CallContract executes a contract call.
 func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
 	b.mu.Lock()
@@ -384,19 +180,12 @@ func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallM
 	if blockNumber != nil && blockNumber.Cmp(b.blockchain.CurrentBlock().Number()) != 0 {
 		return nil, errBlockNumberUnsupported
 	}
-	stateDB, err := b.blockchain.State()
+	state, err := b.blockchain.State()
 	if err != nil {
 		return nil, err
 	}
-	res, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), stateDB)
-	if err != nil {
-		return nil, err
-	}
-	// If the result contains a revert reason, try to unpack and return it.
-	if len(res.Revert()) > 0 {
-		return nil, newRevertError(res)
-	}
-	return res.Return(), res.Err
+	rval, _, _, err := b.callContract(ctx, call, b.blockchain.CurrentBlock(), state)
+	return rval, err
 }
 
 // PendingCallContract executes a contract call on the pending state.
@@ -405,15 +194,8 @@ func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereu
 	defer b.mu.Unlock()
 	defer b.pendingState.RevertToSnapshot(b.pendingState.Snapshot())
 
-	res, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
-	if err != nil {
-		return nil, err
-	}
-	// If the result contains a revert reason, try to unpack and return it.
-	if len(res.Revert()) > 0 {
-		return nil, newRevertError(res)
-	}
-	return res.Return(), res.Err
+	rval, _, _, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
+	return rval, err
 }
 
 // PendingNonceAt implements PendingStateReader.PendingNonceAt, retrieving
@@ -448,57 +230,25 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 	} else {
 		hi = b.pendingBlock.GasLimit()
 	}
-	// Recap the highest gas allowance with account's balance.
-	if call.GasPrice != nil && call.GasPrice.BitLen() != 0 {
-		balance := b.pendingState.GetBalance(call.From) // from can't be nil
-		available := new(big.Int).Set(balance)
-		if call.Value != nil {
-			if call.Value.Cmp(available) >= 0 {
-				return 0, errors.New("insufficient funds for transfer")
-			}
-			available.Sub(available, call.Value)
-		}
-		allowance := new(big.Int).Div(available, call.GasPrice)
-		if allowance.IsUint64() && hi > allowance.Uint64() {
-			transfer := call.Value
-			if transfer == nil {
-				transfer = new(big.Int)
-			}
-			log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
-				"sent", transfer, "gasprice", call.GasPrice, "fundable", allowance)
-			hi = allowance.Uint64()
-		}
-	}
 	cap = hi
 
 	// Create a helper to check if a gas allowance results in an executable transaction
-	executable := func(gas uint64) (bool, *core.ExecutionResult, error) {
+	executable := func(gas uint64) bool {
 		call.Gas = gas
 
 		snapshot := b.pendingState.Snapshot()
-		res, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
+		_, _, failed, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState)
 		b.pendingState.RevertToSnapshot(snapshot)
 
-		if err != nil {
-			if errors.Is(err, core.ErrIntrinsicGas) {
-				return true, nil, nil // Special case, raise gas limit
+		if err != nil || failed {
+			return false
 		}
-			return true, nil, err // Bail out
-		}
-		return res.Failed(), res, nil
+		return true
 	}
 	// Execute the binary search and hone in on an executable gas limit
 	for lo+1 < hi {
 		mid := (hi + lo) / 2
-		failed, _, err := executable(mid)
-
-		// If the error is not nil(consensus error), it means the provided message
-		// call or transaction will never be accepted no matter how much gas it is
-		// assigned. Return the error directly, don't struggle any more
-		if err != nil {
-			return 0, err
-		}
-		if failed {
+		if !executable(mid) {
 			lo = mid
 		} else {
 			hi = mid
@@ -506,19 +256,8 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 	}
 	// Reject the transaction as invalid if it still fails at the highest allowance
 	if hi == cap {
-		failed, result, err := executable(hi)
-		if err != nil {
-			return 0, err
-		}
-		if failed {
-			if result != nil && result.Err != vm.ErrOutOfGas {
-				if len(result.Revert()) > 0 {
-					return 0, newRevertError(result)
-				}
-				return 0, result.Err
-			}
-			// Otherwise, the specified gas cap is too low
-			return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
+		if !executable(hi) {
+			return 0, errGasEstimationFailed
 		}
 	}
 	return hi, nil
@@ -526,7 +265,7 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs
 
 // callContract implements common code between normal and pending contract calls.
 // state is modified during execution, make sure to copy it if necessary.
-func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, stateDB *state.StateDB) (*core.ExecutionResult, error) {
+func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, statedb *state.StateDB) ([]byte, uint64, bool, error) {
 	// Ensure message is initialized properly.
 	if call.GasPrice == nil {
 		call.GasPrice = big.NewInt(1)
@@ -538,19 +277,18 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 		call.Value = new(big.Int)
 	}
 	// Set infinite balance to the fake caller account.
-	from := stateDB.GetOrNewStateObject(call.From)
+	from := statedb.GetOrNewStateObject(call.From)
 	from.SetBalance(math.MaxBig256)
 	// Execute the call.
-	msg := callMsg{call}
+	msg := callmsg{call}
 
-	txContext := core.NewEVMTxContext(msg)
-	evmContext := core.NewEVMBlockContext(block.Header(), b.blockchain, nil)
+	evmContext := core.NewEVMContext(msg, block.Header(), b.blockchain, nil)
 	// Create a new environment which holds all relevant information
 	// about the transaction and calling mechanisms.
-	vmEnv := vm.NewEVM(evmContext, txContext, stateDB, b.config, vm.Config{})
-	gasPool := new(core.GasPool).AddGas(math.MaxUint64)
+	vmenv := vm.NewEVM(evmContext, statedb, b.config, vm.Config{})
+	gaspool := new(core.GasPool).AddGas(math.MaxUint64)
 
-	return core.NewStateTransition(vmEnv, msg, gasPool).TransitionDb()
+	return core.NewStateTransition(vmenv, msg, gaspool).TransitionDb()
 }
 
 // SendTransaction updates the pending block to include the given transaction.
@@ -559,10 +297,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
-	// Check transaction validity.
-	block := b.blockchain.CurrentBlock()
-	signer := types.MakeSigner(b.blockchain.Config(), block.Number())
-	sender, err := types.Sender(signer, tx)
+	sender, err := types.Sender(types.HomesteadSigner{}, tx)
 	if err != nil {
 		panic(fmt.Errorf("invalid transaction: %v", err))
 	}
@@ -571,17 +306,16 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 		panic(fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce))
 	}
 
-	// Include tx in chain.
-	blocks, _ := core.GenerateChain(b.config, block, ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+	blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
 		for _, tx := range b.pendingBlock.Transactions() {
 			block.AddTxWithChain(b.blockchain, tx)
 		}
 		block.AddTxWithChain(b.blockchain, tx)
 	})
-	stateDB, _ := b.blockchain.State()
+	statedb, _ := b.blockchain.State()
 
 	b.pendingBlock = blocks[0]
-	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database())
 	return nil
 }
 
@@ -595,7 +329,7 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 		// Block filter requested, construct a single-shot filter
 		filter = filters.NewBlockFilter(&filterBackend{b.database, b.blockchain}, *query.BlockHash, query.Addresses, query.Topics)
 	} else {
-		// Initialize unset filter boundaries to run from genesis to chain head
+		// Initialize unset filter boundaried to run from genesis to chain head
 		from := int64(0)
 		if query.FromBlock != nil {
 			from = query.FromBlock.Int64()
@@ -613,8 +347,8 @@ func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.Filter
 		return nil, err
 	}
 	res := make([]types.Log, len(logs))
-	for i, nLog := range logs {
-		res[i] = *nLog
+	for i, log := range logs {
+		res[i] = *log
 	}
 	return res, nil
 }
@@ -635,9 +369,9 @@ func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethere
 		for {
 			select {
 			case logs := <-sink:
-				for _, nlog := range logs {
+				for _, log := range logs {
 					select {
-					case ch <- *nlog:
+					case ch <- *log:
 					case err := <-sub.Err():
 						return err
 					case <-quit:
@@ -653,73 +387,37 @@ func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethere
 	}), nil
 }
 
-// SubscribeNewHead returns an event subscription for a new header.
-func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error) {
-	// subscribe to a new head
-	sink := make(chan *types.Header)
-	sub := b.events.SubscribeNewHeads(sink)
-
-	return event.NewSubscription(func(quit <-chan struct{}) error {
-		defer sub.Unsubscribe()
-		for {
-			select {
-			case head := <-sink:
-				select {
-				case ch <- head:
-				case err := <-sub.Err():
-					return err
-				case <-quit:
-					return nil
-				}
-			case err := <-sub.Err():
-				return err
-			case <-quit:
-				return nil
-			}
-		}
-	}), nil
-}
-
 // AdjustTime adds a time shift to the simulated clock.
-// It can only be called on empty blocks.
 func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
-
-	if len(b.pendingBlock.Transactions()) != 0 {
-		return errors.New("Could not adjust time on non-empty block")
-	}
-
 	blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) {
+		for _, tx := range b.pendingBlock.Transactions() {
+			block.AddTx(tx)
+		}
 		block.OffsetTime(int64(adjustment.Seconds()))
 	})
-	stateDB, _ := b.blockchain.State()
+	statedb, _ := b.blockchain.State()
 
 	b.pendingBlock = blocks[0]
-	b.pendingState, _ = state.New(b.pendingBlock.Root(), stateDB.Database(), nil)
+	b.pendingState, _ = state.New(b.pendingBlock.Root(), statedb.Database())
 
 	return nil
 }
 
-// Blockchain returns the underlying blockchain.
-func (b *SimulatedBackend) Blockchain() *core.BlockChain {
-	return b.blockchain
-}
-
-// callMsg implements core.Message to allow passing it as a transaction simulator.
-type callMsg struct {
+// callmsg implements core.Message to allow passing it as a transaction simulator.
+type callmsg struct {
 	ethereum.CallMsg
 }
 
-func (m callMsg) From() common.Address         { return m.CallMsg.From }
-func (m callMsg) Nonce() uint64                { return 0 }
-func (m callMsg) CheckNonce() bool             { return false }
-func (m callMsg) To() *common.Address          { return m.CallMsg.To }
-func (m callMsg) GasPrice() *big.Int           { return m.CallMsg.GasPrice }
-func (m callMsg) Gas() uint64                  { return m.CallMsg.Gas }
-func (m callMsg) Value() *big.Int              { return m.CallMsg.Value }
-func (m callMsg) Data() []byte                 { return m.CallMsg.Data }
-func (m callMsg) AccessList() types.AccessList { return m.CallMsg.AccessList }
+func (m callmsg) From() common.Address { return m.CallMsg.From }
+func (m callmsg) Nonce() uint64        { return 0 }
+func (m callmsg) CheckNonce() bool     { return false }
+func (m callmsg) To() *common.Address  { return m.CallMsg.To }
+func (m callmsg) GasPrice() *big.Int   { return m.CallMsg.GasPrice }
+func (m callmsg) Gas() uint64          { return m.CallMsg.Gas }
+func (m callmsg) Value() *big.Int      { return m.CallMsg.Value }
+func (m callmsg) Data() []byte         { return m.CallMsg.Data }
 
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.
@@ -747,7 +445,7 @@ func (fb *filterBackend) GetReceipts(ctx context.Context, hash common.Hash) (typ
 	if number == nil {
 		return nil, nil
 	}
-	return rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config()), nil
+	return rawdb.ReadReceipts(fb.db, hash, *number), nil
 }
 
 func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*types.Log, error) {
@@ -755,7 +453,7 @@ func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*ty
 	if number == nil {
 		return nil, nil
 	}
-	receipts := rawdb.ReadReceipts(fb.db, hash, *number, fb.bc.Config())
+	receipts := rawdb.ReadReceipts(fb.db, hash, *number)
 	if receipts == nil {
 		return nil, nil
 	}
@@ -767,34 +465,22 @@ func (fb *filterBackend) GetLogs(ctx context.Context, hash common.Hash) ([][]*ty
 }
 
 func (fb *filterBackend) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
-	return nullSubscription()
-}
-
-func (fb *filterBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
-	return fb.bc.SubscribeChainEvent(ch)
-}
-
-func (fb *filterBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
-	return fb.bc.SubscribeRemovedLogsEvent(ch)
-}
-
-func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
-	return fb.bc.SubscribeLogsEvent(ch)
-}
-
-func (fb *filterBackend) SubscribePendingLogsEvent(ch chan<- []*types.Log) event.Subscription {
-	return nullSubscription()
-}
-
-func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
-
-func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
-	panic("not supported")
-}
-
-func nullSubscription() event.Subscription {
 	return event.NewSubscription(func(quit <-chan struct{}) error {
 		<-quit
 		return nil
 	})
 }
+func (fb *filterBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subscription {
+	return fb.bc.SubscribeChainEvent(ch)
+}
+func (fb *filterBackend) SubscribeRemovedLogsEvent(ch chan<- core.RemovedLogsEvent) event.Subscription {
+	return fb.bc.SubscribeRemovedLogsEvent(ch)
+}
+func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {
+	return fb.bc.SubscribeLogsEvent(ch)
+}
+
+func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
+func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
+	panic("not supported")
+}

accounts/abi/bind/base.go

@@ -32,7 +32,7 @@ import (
 
 // SignerFn is a signer function callback when a contract requires a method to
 // sign the transaction before submission.
-type SignerFn func(common.Address, *types.Transaction) (*types.Transaction, error)
+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 {
@@ -49,7 +49,7 @@ type TransactOpts struct {
 	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 the transaction (nil = 0 = no funds)
+	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)
 
@@ -117,14 +117,11 @@ func DeployContract(opts *TransactOpts, abi abi.ABI, bytecode []byte, backend Co
 // 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, results *[]interface{}, method string, params ...interface{}) error {
+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)
 	}
-	if results == nil {
-		results = new([]interface{})
-	}
 	// Pack the input, call and unpack the results
 	input, err := c.abi.Pack(method, params...)
 	if err != nil {
@@ -152,10 +149,7 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 		}
 	} else {
 		output, err = c.caller.CallContract(ctx, msg, opts.BlockNumber)
-		if err != nil {
-			return err
-		}
-		if len(output) == 0 {
+		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
@@ -164,14 +158,10 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 			}
 		}
 	}
-
-	if len(*results) == 0 {
-		res, err := c.abi.Unpack(method, output)
-		*results = res
+	if err != nil {
 		return err
 	}
-	res := *results
-	return c.abi.UnpackIntoInterface(res[0], method, output)
+	return c.abi.Unpack(result, method, output)
 }
 
 // Transact invokes the (paid) contract method with params as input values.
@@ -181,24 +171,12 @@ func (c *BoundContract) Transact(opts *TransactOpts, method string, params ...in
 	if err != nil {
 		return nil, err
 	}
-	// todo(rjl493456442) check the method is payable or not,
-	// reject invalid transaction at the first place
 	return c.transact(opts, &c.address, input)
 }
 
-// RawTransact initiates a transaction with the given raw calldata as the input.
-// It's usually used to initiate transactions for invoking **Fallback** function.
-func (c *BoundContract) RawTransact(opts *TransactOpts, calldata []byte) (*types.Transaction, error) {
-	// todo(rjl493456442) check the method is payable or not,
-	// reject invalid transaction at the first place
-	return c.transact(opts, &c.address, calldata)
-}
-
 // 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) {
-	// todo(rjl493456442) check the payable fallback or receive is defined
-	// or not, reject invalid transaction at the first place
 	return c.transact(opts, &c.address, nil)
 }
 
@@ -240,7 +218,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 			}
 		}
 		// If the contract surely has code (or code is not needed), estimate the transaction
-		msg := ethereum.CallMsg{From: opts.From, To: contract, GasPrice: gasPrice, Value: value, Data: input}
+		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)
@@ -256,7 +234,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	if opts.Signer == nil {
 		return nil, errors.New("no signer to authorize the transaction with")
 	}
-	signedTx, err := opts.Signer(opts.From, rawTx)
+	signedTx, err := opts.Signer(types.HomesteadSigner{}, opts.From, rawTx)
 	if err != nil {
 		return nil, err
 	}
@@ -274,9 +252,9 @@ func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]int
 		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...)
+	query = append([][]interface{}{{c.abi.Events[name].Id()}}, query...)
 
-	topics, err := abi.MakeTopics(query...)
+	topics, err := makeTopics(query...)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -323,9 +301,9 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]inter
 		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...)
+	query = append([][]interface{}{{c.abi.Events[name].Id()}}, query...)
 
-	topics, err := abi.MakeTopics(query...)
+	topics, err := makeTopics(query...)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -349,7 +327,7 @@ func (c *BoundContract) WatchLogs(opts *WatchOpts, name string, query ...[]inter
 // 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.UnpackIntoInterface(out, event, log.Data); err != nil {
+		if err := c.abi.Unpack(out, event, log.Data); err != nil {
 			return err
 		}
 	}
@@ -359,23 +337,7 @@ func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log)
 			indexed = append(indexed, arg)
 		}
 	}
-	return abi.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 abi.ParseTopicsIntoMap(out, indexed, log.Topics[1:])
+	return parseTopics(out, indexed, log.Topics[1:])
 }
 
 // ensureContext is a helper method to ensure a context is not nil, even if the

accounts/abi/bind/base_test.go

@@ -1,43 +1,19 @@
-// 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 (
 	"context"
 	"math/big"
-	"reflect"
-	"strings"
 	"testing"
 
-	"github.com/ethereum/go-ethereum"
+	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/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
-	pendingCodeAtCalled       bool
-	pendingCallContractCalled bool
 }
 
 func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
@@ -50,15 +26,6 @@ func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, b
 	return nil, nil
 }
 
-func (mc *mockCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
-	mc.pendingCodeAtCalled = true
-	return nil, nil
-}
-
-func (mc *mockCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
-	mc.pendingCallContractCalled = true
-	return nil, nil
-}
 func TestPassingBlockNumber(t *testing.T) {
 
 	mc := &mockCaller{}
@@ -71,10 +38,11 @@ func TestPassingBlockNumber(t *testing.T) {
 			},
 		},
 	}, mc, nil, nil)
+	var ret string
 
 	blockNumber := big.NewInt(42)
 
-	bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, nil, "something")
+	bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, &ret, "something")
 
 	if mc.callContractBlockNumber != blockNumber {
 		t.Fatalf("CallContract() was not passed the block number")
@@ -84,7 +52,7 @@ func TestPassingBlockNumber(t *testing.T) {
 		t.Fatalf("CodeAt() was not passed the block number")
 	}
 
-	bc.Call(&bind.CallOpts{}, nil, "something")
+	bc.Call(&bind.CallOpts{}, &ret, "something")
 
 	if mc.callContractBlockNumber != nil {
 		t.Fatalf("CallContract() was passed a block number when it should not have been")
@@ -93,165 +61,4 @@ func TestPassingBlockNumber(t *testing.T) {
 	if mc.codeAtBlockNumber != nil {
 		t.Fatalf("CodeAt() was passed a block number when it should not have been")
 	}
-
-	bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, nil, "something")
-
-	if !mc.pendingCallContractCalled {
-		t.Fatalf("CallContract() was not passed the block number")
-	}
-
-	if !mc.pendingCodeAtCalled {
-		t.Fatalf("CodeAt() was not passed the block number")
-	}
-}
-
-const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158"
-
-func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
-	hash := crypto.Keccak256Hash([]byte("testName"))
-	topics := []common.Hash{
-		common.HexToHash("0x0"),
-		hash,
-	}
-	mockLog := newMockLog(topics, common.HexToHash("0x0"))
-
-	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)
-
-	expectedReceivedMap := map[string]interface{}{
-		"name":   hash,
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
-}
-
-func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
-	sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	hash := crypto.Keccak256Hash(sliceBytes)
-	topics := []common.Hash{
-		common.HexToHash("0x0"),
-		hash,
-	}
-	mockLog := newMockLog(topics, common.HexToHash("0x0"))
-
-	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)
-
-	expectedReceivedMap := map[string]interface{}{
-		"names":  hash,
-		"sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount": big.NewInt(1),
-		"memo":   []byte{88},
-	}
-	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
-}
-
-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)
-	topics := []common.Hash{
-		common.HexToHash("0x0"),
-		hash,
-	}
-	mockLog := newMockLog(topics, common.HexToHash("0x0"))
-
-	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)
-
-	expectedReceivedMap := map[string]interface{}{
-		"addresses": hash,
-		"sender":    common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":    big.NewInt(1),
-		"memo":      []byte{88},
-	}
-	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
-}
-
-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])
-	topics := []common.Hash{
-		common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
-		common.BytesToHash(functionTyBytes),
-	}
-	mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
-	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)
-
-	expectedReceivedMap := map[string]interface{}{
-		"function": functionTy,
-		"sender":   common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":   big.NewInt(1),
-		"memo":     []byte{88},
-	}
-	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
-}
-
-func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
-	bytes := []byte{1, 2, 3, 4, 5}
-	hash := crypto.Keccak256Hash(bytes)
-	topics := []common.Hash{
-		common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
-		hash,
-	}
-	mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
-
-	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)
-
-	expectedReceivedMap := map[string]interface{}{
-		"content": hash,
-		"sender":  common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
-		"amount":  big.NewInt(1),
-		"memo":    []byte{88},
-	}
-	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
-}
-
-func unpackAndCheck(t *testing.T, bc *bind.BoundContract, expected map[string]interface{}, mockLog types.Log) {
-	received := make(map[string]interface{})
-	if err := bc.UnpackLogIntoMap(received, "received", mockLog); err != nil {
-		t.Error(err)
-	}
-
-	if len(received) != len(expected) {
-		t.Fatalf("unpacked map length %v not equal expected length of %v", len(received), len(expected))
-	}
-	for name, elem := range expected {
-		if !reflect.DeepEqual(elem, received[name]) {
-			t.Errorf("field %v does not match expected, want %v, got %v", name, elem, received[name])
-		}
-	}
-}
-
-func newMockLog(topics []common.Hash, txHash common.Hash) types.Log {
-	return types.Log{
-		Address:     common.HexToAddress("0x0"),
-		Topics:      topics,
-		Data:        hexutil.MustDecode(hexData),
-		BlockNumber: uint64(26),
-		TxHash:      txHash,
-		TxIndex:     111,
-		BlockHash:   common.BytesToHash([]byte{1, 2, 3, 4, 5}),
-		Index:       7,
-		Removed:     false,
-	}
 }

accounts/abi/bind/bind.go

@@ -22,7 +22,6 @@ package bind
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"go/format"
 	"regexp"
@@ -31,7 +30,6 @@ import (
 	"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.
@@ -47,17 +45,10 @@ const (
 // 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, aliases map[string]string) (string, error) {
-	var (
-		// contracts is the map of each individual contract requested binding
-		contracts = make(map[string]*tmplContract)
+func Bind(types []string, abis []string, bytecodes []string, pkg string, lang Lang) (string, error) {
+	// Process each individual contract requested binding
+	contracts := make(map[string]*tmplContract)
 
-		// structs is the map of all redeclared structs shared by passed contracts.
-		structs = make(map[string]*tmplStruct)
-
-		// isLib is the 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]))
@@ -72,45 +63,23 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			return r
 		}, abis[i])
 
-		// Extract the call and transact methods; events, struct definitions; and sort them alphabetically
+		// Extract the call and transact methods; events; and sort them alphabetically
 		var (
 			calls     = make(map[string]*tmplMethod)
 			transacts = make(map[string]*tmplMethod)
 			events    = make(map[string]*tmplEvent)
-			fallback  *tmplMethod
-			receive   *tmplMethod
-
-			// identifiers are used to detect duplicated identifiers of functions
-			// and events. For all calls, transacts and events, abigen will generate
-			// corresponding bindings. However we have to ensure there is no
-			// identifier collisions in the bindings of these categories.
-			callIdentifiers     = make(map[string]bool)
-			transactIdentifiers = make(map[string]bool)
-			eventIdentifiers    = make(map[string]bool)
 		)
 		for _, original := range evmABI.Methods {
 			// Normalize the method for capital cases and non-anonymous inputs/outputs
 			normalized := original
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
-			// Ensure there is no duplicated identifier
-			var identifiers = callIdentifiers
-			if !original.IsConstant() {
-				identifiers = transactIdentifiers
-			}
-			if identifiers[normalizedName] {
-				return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName)
-			}
-			identifiers[normalizedName] = true
-			normalized.Name = normalizedName
+			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 hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
-				}
 			}
 			normalized.Outputs = make([]abi.Argument, len(original.Outputs))
 			copy(normalized.Outputs, original.Outputs)
@@ -118,12 +87,9 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 				if output.Name != "" {
 					normalized.Outputs[j].Name = capitalise(output.Name)
 				}
-				if hasStruct(output.Type) {
-					bindStructType[lang](output.Type, structs)
-				}
 			}
 			// Append the methods to the call or transact lists
-			if original.IsConstant() {
+			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)}
@@ -136,83 +102,35 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			}
 			// Normalize the event for capital cases and non-anonymous outputs
 			normalized := original
-
-			// Ensure there is no duplicated identifier
-			normalizedName := methodNormalizer[lang](alias(aliases, original.Name))
-			if eventIdentifiers[normalizedName] {
-				return "", fmt.Errorf("duplicated identifier \"%s\"(normalized \"%s\"), use --alias for renaming", original.Name, normalizedName)
-			}
-			eventIdentifiers[normalizedName] = true
-			normalized.Name = normalizedName
+			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 hasStruct(input.Type) {
-					bindStructType[lang](input.Type, structs)
 				}
 			}
 			// Append the event to the accumulator list
 			events[original.Name] = &tmplEvent{Original: original, Normalized: normalized}
 		}
-		// Add two special fallback functions if they exist
-		if evmABI.HasFallback() {
-			fallback = &tmplMethod{Original: evmABI.Fallback}
-		}
-		if evmABI.HasReceive() {
-			receive = &tmplMethod{Original: evmABI.Receive}
-		}
-		// 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"),
+			InputBin:    strings.TrimSpace(bytecodes[i]),
 			Constructor: evmABI.Constructor,
 			Calls:       calls,
 			Transacts:   transacts,
-			Fallback:    fallback,
-			Receive:     receive,
 			Events:      events,
-			Libraries:   make(map[string]string),
 		}
-		// 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,
-		Structs:   structs,
 	}
 	buffer := new(bytes.Buffer)
 
@@ -241,67 +159,129 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 
 // 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{
+var bindType = map[Lang]func(kind abi.Type) string{
 	LangGo:   bindTypeGo,
 	LangJava: bindTypeJava,
 }
 
-// bindBasicTypeGo converts basic solidity types(except array, slice and tuple) to Go ones.
-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())
+// Helper function for the binding generators.
+// It reads the unmatched characters after the inner type-match,
+//  (since the inner type is a prefix of the total type declaration),
+//  looks for valid arrays (possibly a dynamic one) wrapping the inner type,
+//  and returns the sizes of these arrays.
+//
+// Returned array sizes are in the same order as solidity signatures; inner array size first.
+// Array sizes may also be "", indicating a dynamic array.
+func wrapArray(stringKind string, innerLen int, innerMapping string) (string, []string) {
+	remainder := stringKind[innerLen:]
+	//find all the sizes
+	matches := regexp.MustCompile(`\[(\d*)\]`).FindAllStringSubmatch(remainder, -1)
+	parts := make([]string, 0, len(matches))
+	for _, match := range matches {
+		//get group 1 from the regex match
+		parts = append(parts, match[1])
+	}
+	return innerMapping, parts
+}
+
+// Translates the array sizes to a Go-lang declaration of a (nested) array of the inner type.
+// Simply returns the inner type if arraySizes is empty.
+func arrayBindingGo(inner string, arraySizes []string) string {
+	out := ""
+	//prepend all array sizes, from outer (end arraySizes) to inner (start arraySizes)
+	for i := len(arraySizes) - 1; i >= 0; i-- {
+		out += "[" + arraySizes[i] + "]"
+	}
+	out += inner
+	return out
+}
+
+// bindTypeGo converts a Solidity type to a Go one. 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. *big.Int).
+func bindTypeGo(kind abi.Type) string {
+	stringKind := kind.String()
+	innerLen, innerMapping := bindUnnestedTypeGo(stringKind)
+	return arrayBindingGo(wrapArray(stringKind, innerLen, innerMapping))
+}
+
+// The inner function of bindTypeGo, this finds the inner type of stringKind.
+// (Or just the type itself if it is not an array or slice)
+// The length of the matched part is returned, with the translated type.
+func bindUnnestedTypeGo(stringKind string) (int, string) {
+
+	switch {
+	case strings.HasPrefix(stringKind, "address"):
+		return len("address"), "common.Address"
+
+	case strings.HasPrefix(stringKind, "bytes"):
+		parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind)
+		return len(parts[0]), fmt.Sprintf("[%s]byte", parts[1])
+
+	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
+		parts := regexp.MustCompile(`(u)?int([0-9]*)`).FindStringSubmatch(stringKind)
 		switch parts[2] {
 		case "8", "16", "32", "64":
-			return fmt.Sprintf("%sint%s", parts[1], parts[2])
+			return len(parts[0]), 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"
+		return len(parts[0]), "*big.Int"
+
+	case strings.HasPrefix(stringKind, "bool"):
+		return len("bool"), "bool"
+
+	case strings.HasPrefix(stringKind, "string"):
+		return len("string"), "string"
+
 	default:
-		// string, bool types
-		return kind.String()
+		return len(stringKind), stringKind
 	}
 }
 
-// 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
+// Translates the array sizes to a Java declaration of a (nested) array of the inner type.
+// Simply returns the inner type if arraySizes is empty.
+func arrayBindingJava(inner string, arraySizes []string) string {
+	// Java array type declarations do not include the length.
+	return inner + strings.Repeat("[]", len(arraySizes))
+}
+
+// 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 bindTypeGo(kind abi.Type, structs map[string]*tmplStruct) string {
-	switch kind.T {
-	case abi.TupleTy:
-		return structs[kind.TupleRawName+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)
-	}
+func bindTypeJava(kind abi.Type) string {
+	stringKind := kind.String()
+	innerLen, innerMapping := bindUnnestedTypeJava(stringKind)
+	return arrayBindingJava(wrapArray(stringKind, innerLen, innerMapping))
 }
 
-// bindBasicTypeJava converts basic solidity types(except array, slice and tuple) to Java ones.
-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()
+// The inner function of bindTypeJava, this finds the inner type of stringKind.
+// (Or just the type itself if it is not an array or slice)
+// The length of the matched part is returned, with the translated type.
+func bindUnnestedTypeJava(stringKind string) (int, string) {
+
+	switch {
+	case strings.HasPrefix(stringKind, "address"):
+		parts := regexp.MustCompile(`address(\[[0-9]*\])?`).FindStringSubmatch(stringKind)
+		if len(parts) != 2 {
+			return len(stringKind), stringKind
 		}
-		// All unsigned integers should be translated to BigInt since gomobile doesn't
-		// support them.
-		if parts[1] == "u" {
-			return "BigInt"
+		if parts[1] == "" {
+			return len("address"), "Address"
+		}
+		return len(parts[0]), "Addresses"
+
+	case strings.HasPrefix(stringKind, "bytes"):
+		parts := regexp.MustCompile(`bytes([0-9]*)`).FindStringSubmatch(stringKind)
+		if len(parts) != 2 {
+			return len(stringKind), stringKind
+		}
+		return len(parts[0]), "byte[]"
+
+	case strings.HasPrefix(stringKind, "int") || strings.HasPrefix(stringKind, "uint"):
+		//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(stringKind)
+		if len(parts) != 3 {
+			return len(stringKind), stringKind
 		}
 
 		namedSize := map[string]string{
@@ -311,182 +291,52 @@ func bindBasicTypeJava(kind abi.Type) string {
 			"64": "long",
 		}[parts[2]]
 
-		// default to BigInt
+		//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()
-	}
-}
+		return len(parts[0]), namedSize
 
-// pluralizeJavaType explicitly converts multidimensional types to predefined
-// types 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 + "[]"
-}
+	case strings.HasPrefix(stringKind, "bool"):
+		return len("bool"), "boolean"
+
+	case strings.HasPrefix(stringKind, "string"):
+		return len("string"), "String"
 
-// 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.TupleRawName+kind.String()].Name
-	case abi.ArrayTy, abi.SliceTy:
-		return pluralizeJavaType(bindTypeJava(*kind.Elem, structs))
 	default:
-		return bindBasicTypeJava(kind)
+		return len(stringKind), stringKind
 	}
 }
 
 // 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{
+var bindTopicType = map[Lang]func(kind abi.Type) string{
 	LangGo:   bindTopicTypeGo,
 	LangJava: bindTopicTypeJava,
 }
 
-// bindTopicTypeGo converts a Solidity topic type to a Go one. It is almost the same
-// functionality 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)
-
-	// todo(rjl493456442) according solidity documentation, indexed event
-	// parameters that are not value types i.e. arrays and structs are not
-	// stored directly but instead a keccak256-hash of an encoding is stored.
-	//
-	// We only convert stringS and bytes to hash, still need to deal with
-	// array(both fixed-size and dynamic-size) and struct.
+// bindTypeGo 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) string {
+	bound := bindTypeGo(kind)
 	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
-// functionality 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)
-
-	// todo(rjl493456442) according solidity documentation, indexed event
-	// parameters that are not value types i.e. arrays and structs are not
-	// stored directly but instead a keccak256-hash of an encoding is stored.
-	//
-	// We only convert strings and bytes to hash, still need to deal with
-	// array(both fixed-size and dynamic-size) and struct.
-	if bound == "String" || bound == "byte[]" {
+// bindTypeGo 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) string {
+	bound := bindTypeJava(kind)
+	if bound == "String" || bound == "Bytes" {
 		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:
-		// We compose a raw struct name and a canonical parameter expression
-		// together here. The reason is before solidity v0.5.11, kind.TupleRawName
-		// is empty, so we use canonical parameter expression to distinguish
-		// different struct definition. From the consideration of backward
-		// compatibility, we concat these two together so that if kind.TupleRawName
-		// is not empty, it can have unique id.
-		id := kind.TupleRawName + kind.String()
-		if s, exist := structs[id]; 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 := kind.TupleRawName
-		if name == "" {
-			name = fmt.Sprintf("Struct%d", len(structs))
-		}
-		structs[id] = &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:
-		// We compose a raw struct name and a canonical parameter expression
-		// together here. The reason is before solidity v0.5.11, kind.TupleRawName
-		// is empty, so we use canonical parameter expression to distinguish
-		// different struct definition. From the consideration of backward
-		// compatibility, we concat these two together so that if kind.TupleRawName
-		// is not empty, it can have unique id.
-		id := kind.TupleRawName + kind.String()
-		if s, exist := structs[id]; 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 := kind.TupleRawName
-		if name == "" {
-			name = fmt.Sprintf("Class%d", len(structs))
-		}
-		structs[id] = &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 may be used inside method names.
+// 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,
@@ -498,8 +348,18 @@ func namedTypeJava(javaKind string, solKind abi.Type) string {
 	switch javaKind {
 	case "byte[]":
 		return "Binary"
+	case "byte[][]":
+		return "Binaries"
+	case "string":
+		return "String"
+	case "string[]":
+		return "Strings"
 	case "boolean":
 		return "Bool"
+	case "boolean[]":
+		return "Bools"
+	case "BigInt[]":
+		return "BigInts"
 	default:
 		parts := regexp.MustCompile(`(u)?int([0-9]*)(\[[0-9]*\])?`).FindStringSubmatch(solKind.String())
 		if len(parts) != 4 {
@@ -518,24 +378,17 @@ func namedTypeJava(javaKind string, solKind abi.Type) string {
 	}
 }
 
-// alias returns an alias of the given string based on the aliasing rules
-// or returns itself if no rule is matched.
-func alias(aliases map[string]string, n string) string {
-	if alias, exist := aliases[n]; exist {
-		return alias
-	}
-	return n
-}
-
 // methodNormalizer is a name transformer that modifies Solidity method names to
-// conform to target language naming conventions.
+// 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.
-var capitalise = abi.ToCamelCase
+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 {
@@ -569,18 +422,3 @@ func structured(args abi.Arguments) bool {
 	}
 	return true
 }
-
-// hasStruct returns an indicator whether the given type is struct, struct slice
-// or struct array.
-func hasStruct(t abi.Type) bool {
-	switch t.T {
-	case abi.SliceTy:
-		return hasStruct(*t.Elem)
-	case abi.ArrayTy:
-		return hasStruct(*t.Elem)
-	case abi.TupleTy:
-		return true
-	default:
-		return false
-	}
-}

accounts/abi/bind/template.go

@@ -22,24 +22,17 @@ import "github.com/ethereum/go-ethereum/accounts/abi"
 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
-	Structs   map[string]*tmplStruct   // Contract struct type definitions
 }
 
 // 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 generate deploy code from
-	FuncSigs    map[string]string      // Optional map: string signature -> 4-byte signature
+	InputBin    string                 // Optional EVM bytecode used to denetare deploy code from
 	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
-	Fallback    *tmplMethod            // Additional special fallback function
-	Receive     *tmplMethod            // Additional special receive function
 	Events      map[string]*tmplEvent  // Contract events accessors
-	Libraries   map[string]string      // Same as tmplData, but filtered to only keep what the contract needs
-	Library     bool                   // Indicator whether the contract is a library
 }
 
 // tmplMethod is a wrapper around an abi.Method that contains a few preprocessed
@@ -50,28 +43,12 @@ type tmplMethod struct {
 	Structured bool       // Whether the returns should be accumulated into a struct
 }
 
-// tmplEvent is a wrapper around an abi.Event that contains a few preprocessed
-// and cached data fields.
+// 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 and contains an auto-generated
-// struct name.
-type tmplStruct struct {
-	Name   string       // Auto-generated struct name(before solidity v0.5.11) or raw name.
-	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{
@@ -79,8 +56,8 @@ var tmplSource = map[Lang]string{
 	LangJava: tmplSourceJava,
 }
 
-// tmplSourceGo is the Go source template that the generated Go contract binding
-// is based on.
+// 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.
@@ -104,47 +81,27 @@ var (
 	_ = big.NewInt
 	_ = strings.NewReader
 	_ = ethereum.NotFound
+	_ = abi.U256
 	_ = bind.Bind
 	_ = common.Big1
 	_ = types.BloomLookup
 	_ = event.NewSubscription
 )
 
-{{$structs := .Structs}}
-{{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 $contract := .Contracts}}
 	// {{.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}}"
+		const {{.Type}}Bin = ` + "`" + `{{.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) {
+		func Deploy{{.Type}}(auth *bind.TransactOpts, backend bind.ContractBackend {{range .Constructor.Inputs}}, {{.Name}} {{bindtype .Type}}{{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
@@ -261,7 +218,7 @@ var (
 	// 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 {
+	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...)
 	}
 
@@ -280,7 +237,7 @@ var (
 	// 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 {
+	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...)
 	}
 
@@ -296,116 +253,63 @@ var (
 	}
 
 	{{range .Calls}}
-		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.ID}}.
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
-			var out []interface{}
-			err := _{{$contract.Type}}.contract.Call(opts, &out, "{{.Original.Name}}" {{range .Normalized.Inputs}}, {{.Name}}{{end}})
-			{{if .Structured}}
-			outstruct := new(struct{ {{range .Normalized.Outputs}} {{.Name}} {{bindtype .Type $structs}}; {{end}} })
-			if err != nil {
-				return *outstruct, err
-			}
-			{{range $i, $t := .Normalized.Outputs}} 
-			outstruct.{{.Name}} = *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
-
-			return *outstruct, err
-			{{else}}
-			if err != nil {
-				return {{range $i, $_ := .Normalized.Outputs}}*new({{bindtype .Type $structs}}), {{end}} err
-			}
-			{{range $i, $t := .Normalized.Outputs}}
-			out{{$i}} := *abi.ConvertType(out[{{$i}}], new({{bindtype .Type $structs}})).(*{{bindtype .Type $structs}}){{end}}
-			
-			return {{range $i, $t := .Normalized.Outputs}}out{{$i}}, {{end}} err
+		func (_{{$contract.Type}} *{{$contract.Type}}Caller) {{.Normalized.Name}}(opts *bind.CallOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type}};{{end}} },{{else}}{{range .Normalized.Outputs}}{{bindtype .Type}},{{end}}{{end}} error) {
+			{{if .Structured}}ret := new(struct{
+				{{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type}}
 				{{end}}
+			}){{else}}var (
+				{{range $i, $_ := .Normalized.Outputs}}ret{{$i}} = new({{bindtype .Type}})
+				{{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}}.
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type}},{{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}}.
+		// {{.Normalized.Name}} is a free data retrieval call binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
+		func (_{{$contract.Type}} *{{$contract.Type}}CallerSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type}} {{end}}) ({{if .Structured}}struct{ {{range .Normalized.Outputs}}{{.Name}} {{bindtype .Type}};{{end}} }, {{else}} {{range .Normalized.Outputs}}{{bindtype .Type}},{{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}}.
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type $structs}} {{end}}) (*types.Transaction, error) {
+		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) {{.Normalized.Name}}(opts *bind.TransactOpts {{range .Normalized.Inputs}}, {{.Name}} {{bindtype .Type}} {{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}}.
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
+		func (_{{$contract.Type}} *{{$contract.Type}}Session) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type}} {{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}}.
+		// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
+		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) {{.Normalized.Name}}({{range $i, $_ := .Normalized.Inputs}}{{if ne $i 0}},{{end}} {{.Name}} {{bindtype .Type}} {{end}}) (*types.Transaction, error) {
 		  return _{{$contract.Type}}.Contract.{{.Normalized.Name}}(&_{{$contract.Type}}.TransactOpts {{range $i, $_ := .Normalized.Inputs}}, {{.Name}}{{end}})
 		}
 	{{end}}
 
-	{{if .Fallback}} 
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		//
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.RawTransact(opts, calldata)
-		}
-
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		//
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) Fallback(calldata []byte) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
-		}
-	
-		// Fallback is a paid mutator transaction binding the contract fallback function.
-		// 
-		// Solidity: {{.Fallback.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Fallback(calldata []byte) (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Fallback(&_{{$contract.Type}}.TransactOpts, calldata)
-		}
-	{{end}}
-
-	{{if .Receive}} 
-		// Receive is a paid mutator transaction binding the contract receive function.
-		//
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Transactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
-			return _{{$contract.Type}}.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
-		}
-
-		// Receive is a paid mutator transaction binding the contract receive function.
-		//
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}Session) Receive() (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
-		}
-	
-		// Receive is a paid mutator transaction binding the contract receive function.
-		// 
-		// Solidity: {{.Receive.Original.String}}
-		func (_{{$contract.Type}} *{{$contract.Type}}TransactorSession) Receive() (*types.Transaction, error) {
-		  return _{{$contract.Type}}.Contract.Receive(&_{{$contract.Type}}.TransactOpts)
-		}
-	{{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 {
@@ -473,14 +377,14 @@ var (
 
 		// {{$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}}
+			{{capitalise .Name}} {{if .Indexed}}{{bindtopictype .Type}}{{else}}{{bindtype .Type}}{{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}}.
+		// Filter{{.Normalized.Name}} is a free log retrieval operation binding the contract event 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
- 		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) {
+ 		func (_{{$contract.Type}} *{{$contract.Type}}Filterer) Filter{{.Normalized.Name}}(opts *bind.FilterOpts{{range .Normalized.Inputs}}{{if .Indexed}}, {{.Name}} []{{bindtype .Type}}{{end}}{{end}}) (*{{$contract.Type}}{{.Normalized.Name}}Iterator, error) {
 			{{range .Normalized.Inputs}}
 			{{if .Indexed}}var {{.Name}}Rule []interface{}
 			for _, {{.Name}}Item := range {{.Name}} {
@@ -494,10 +398,10 @@ var (
 			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}}.
+		// Watch{{.Normalized.Name}} is a free log subscription operation binding the contract event 0x{{printf "%x" .Original.Id}}.
 		//
 		// Solidity: {{.Original.String}}
-		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) {
+		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}}{{end}}{{end}}) (event.Subscription, error) {
 			{{range .Normalized.Inputs}}
 			{{if .Indexed}}var {{.Name}}Rule []interface{}
 			for _, {{.Name}}Item := range {{.Name}} {
@@ -535,25 +439,12 @@ var (
 				}
 			}), 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
-			}
-			event.Raw = log
-			return event, nil
-		}
-
  	{{end}}
 {{end}}
 `
 
-// tmplSourceJava is the Java source template that the generated Java contract binding
-// is based on.
+// 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!
@@ -561,42 +452,24 @@ const tmplSourceJava = `
 package {{.Package}};
 
 import org.ethereum.geth.*;
-import java.util.*;
+import org.ethereum.geth.internal.*;
 
-{{$structs := .Structs}}
 {{range $contract := .Contracts}}
-{{if not .Library}}public {{end}}class {{.Type}} {
+	public 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}}";
+			public final static byte[] BYTECODE = "{{.InputBin}}".getBytes();
 
 			// 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 {
+			public static {{.Type}} deploy(TransactOpts auth, EthereumClient client{{range .Constructor.Inputs}}, {{bindtype .Type}} {{.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));
+				{{range $index, $element := .Constructor.Inputs}}
+				  args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
 				{{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));
+				return new {{.Type}}(Geth.deployContract(auth, ABI, BYTECODE, client, args));
 			}
 
 			// Internal constructor used by contract deployment.
@@ -625,21 +498,21 @@ import java.util.*;
 			{{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}};
+				{{range $index, $item := .Normalized.Outputs}}public {{bindtype .Type}} {{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}}.
+			// {{.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 if eq (len .Normalized.Outputs) 0}}void{{else}}{{range .Normalized.Outputs}}{{bindtype .Type $structs}}{{end}}{{end}} {{.Normalized.Name}}(CallOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type $structs}} {{.Name}}{{end}}) throws Exception {
+			public {{if gt (len .Normalized.Outputs) 1}}{{capitalise .Normalized.Name}}Results{{else}}{{range .Normalized.Outputs}}{{bindtype .Type}}{{end}}{{end}} {{.Normalized.Name}}(CallOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type}} {{.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}});
+				{{range $index, $item := .Normalized.Inputs}}args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
 				{{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}});
+				{{range $index, $item := .Normalized.Outputs}}Interface result{{$index}} = Geth.newInterface(); result{{$index}}.setDefault{{namedtype (bindtype .Type) .Type}}(); results.set({{$index}}, result{{$index}});
 				{{end}}
 
 				if (opts == null) {
@@ -648,43 +521,26 @@ import java.util.*;
 				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}}();
+					{{range $index, $item := .Normalized.Outputs}}result.{{if ne .Name ""}}{{.Name}}{{else}}Return{{$index}}{{end}} = results.get({{$index}}).get{{namedtype (bindtype .Type) .Type}}();
 					{{end}}
 					return result;
-		{{else}}{{range .Normalized.Outputs}}return results.get(0).get{{namedtype (bindtype .Type $structs) .Type}}();{{end}}
+				{{else}}{{range .Normalized.Outputs}}return results.get(0).get{{namedtype (bindtype .Type) .Type}}();{{end}}
 				{{end}}
 			}
 		{{end}}
 
 		{{range .Transacts}}
-	// {{.Normalized.Name}} is a paid mutator transaction binding the contract method 0x{{printf "%x" .Original.ID}}.
+			// {{.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 {
+			public Transaction {{.Normalized.Name}}(TransactOpts opts{{range .Normalized.Inputs}}, {{bindtype .Type}} {{.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}});
+				{{range $index, $item := .Normalized.Inputs}}args.set({{$index}}, Geth.newInterface()); args.get({{$index}}).set{{namedtype (bindtype .Type) .Type}}({{.Name}});
 				{{end}}
+
 				return this.Contract.transact(opts, "{{.Original.Name}}"	, args);
 			}
 		{{end}}
-
-    {{if .Fallback}}
-	// Fallback is a paid mutator transaction binding the contract fallback function.
-	//
-	// Solidity: {{.Fallback.Original.String}}
-	public Transaction Fallback(TransactOpts opts, byte[] calldata) throws Exception { 
-		return this.Contract.rawTransact(opts, calldata);
 	}
-    {{end}}
-
-    {{if .Receive}}
-	// Receive is a paid mutator transaction binding the contract receive function.
-	//
-	// Solidity: {{.Receive.Original.String}}
-	public Transaction Receive(TransactOpts opts) throws Exception { 
-		return this.Contract.rawTransact(opts, null);
-	}
-    {{end}}
-}
 {{end}}
 `

accounts/abi/bind/topics.go

@@ -0,0 +1,189 @@
+// 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 bind
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+// makeTopics converts a filter query argument list into a filter topic set.
+func makeTopics(query ...[]interface{}) ([][]common.Hash, error) {
+	topics := make([][]common.Hash, len(query))
+	for i, filter := range query {
+		for _, rule := range filter {
+			var topic common.Hash
+
+			// Try to generate the topic based on simple types
+			switch rule := rule.(type) {
+			case common.Hash:
+				copy(topic[:], rule[:])
+			case common.Address:
+				copy(topic[common.HashLength-common.AddressLength:], rule[:])
+			case *big.Int:
+				blob := rule.Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case bool:
+				if rule {
+					topic[common.HashLength-1] = 1
+				}
+			case int8:
+				blob := big.NewInt(int64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case int16:
+				blob := big.NewInt(int64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case int32:
+				blob := big.NewInt(int64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case int64:
+				blob := big.NewInt(rule).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case uint8:
+				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case uint16:
+				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case uint32:
+				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case uint64:
+				blob := new(big.Int).SetUint64(rule).Bytes()
+				copy(topic[common.HashLength-len(blob):], blob)
+			case string:
+				hash := crypto.Keccak256Hash([]byte(rule))
+				copy(topic[:], hash[:])
+			case []byte:
+				hash := crypto.Keccak256Hash(rule)
+				copy(topic[:], hash[:])
+
+			default:
+				// Attempt to generate the topic from funky types
+				val := reflect.ValueOf(rule)
+
+				switch {
+				case val.Kind() == reflect.Array && reflect.TypeOf(rule).Elem().Kind() == reflect.Uint8:
+					reflect.Copy(reflect.ValueOf(topic[common.HashLength-val.Len():]), val)
+
+				default:
+					return nil, fmt.Errorf("unsupported indexed type: %T", rule)
+				}
+			}
+			topics[i] = append(topics[i], topic)
+		}
+	}
+	return topics, nil
+}
+
+// Big batch of reflect types for topic reconstruction.
+var (
+	reflectHash    = reflect.TypeOf(common.Hash{})
+	reflectAddress = reflect.TypeOf(common.Address{})
+	reflectBigInt  = reflect.TypeOf(new(big.Int))
+)
+
+// parseTopics converts the indexed topic fields into actual log field values.
+//
+// Note, dynamic types cannot be reconstructed since they get mapped to Keccak256
+// hashes as the topic value!
+func parseTopics(out interface{}, fields abi.Arguments, topics []common.Hash) error {
+	// Sanity check that the fields and topics match up
+	if len(fields) != len(topics) {
+		return errors.New("topic/field count mismatch")
+	}
+	// Iterate over all the fields and reconstruct them from topics
+	for _, arg := range fields {
+		if !arg.Indexed {
+			return errors.New("non-indexed field in topic reconstruction")
+		}
+		field := reflect.ValueOf(out).Elem().FieldByName(capitalise(arg.Name))
+
+		// Try to parse the topic back into the fields based on primitive types
+		switch field.Kind() {
+		case reflect.Bool:
+			if topics[0][common.HashLength-1] == 1 {
+				field.Set(reflect.ValueOf(true))
+			}
+		case reflect.Int8:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(int8(num.Int64())))
+
+		case reflect.Int16:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(int16(num.Int64())))
+
+		case reflect.Int32:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(int32(num.Int64())))
+
+		case reflect.Int64:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(num.Int64()))
+
+		case reflect.Uint8:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(uint8(num.Uint64())))
+
+		case reflect.Uint16:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(uint16(num.Uint64())))
+
+		case reflect.Uint32:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(uint32(num.Uint64())))
+
+		case reflect.Uint64:
+			num := new(big.Int).SetBytes(topics[0][:])
+			field.Set(reflect.ValueOf(num.Uint64()))
+
+		default:
+			// Ran out of plain primitive types, try custom types
+			switch field.Type() {
+			case reflectHash: // Also covers all dynamic types
+				field.Set(reflect.ValueOf(topics[0]))
+
+			case reflectAddress:
+				var addr common.Address
+				copy(addr[:], topics[0][common.HashLength-common.AddressLength:])
+				field.Set(reflect.ValueOf(addr))
+
+			case reflectBigInt:
+				num := new(big.Int).SetBytes(topics[0][:])
+				field.Set(reflect.ValueOf(num))
+
+			default:
+				// Ran out of custom types, try the crazies
+				switch {
+				case arg.Type.T == abi.FixedBytesTy:
+					reflect.Copy(field, reflect.ValueOf(topics[0][common.HashLength-arg.Type.Size:]))
+
+				default:
+					return fmt.Errorf("unsupported indexed type: %v", arg.Type)
+				}
+			}
+		}
+		topics = topics[1:]
+	}
+	return nil
+}

accounts/abi/bind/util.go

@@ -18,7 +18,7 @@ package bind
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -56,14 +56,14 @@ func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*ty
 // contract address when it is mined. It stops waiting when ctx is canceled.
 func WaitDeployed(ctx context.Context, b DeployBackend, tx *types.Transaction) (common.Address, error) {
 	if tx.To() != nil {
-		return common.Address{}, errors.New("tx is not contract creation")
+		return common.Address{}, fmt.Errorf("tx is not contract creation")
 	}
 	receipt, err := WaitMined(ctx, b, tx)
 	if err != nil {
 		return common.Address{}, err
 	}
 	if receipt.ContractAddress == (common.Address{}) {
-		return common.Address{}, errors.New("zero address")
+		return common.Address{}, fmt.Errorf("zero address")
 	}
 	// Check that code has indeed been deployed at the address.
 	// This matters on pre-Homestead chains: OOG in the constructor

accounts/abi/bind/util_test.go

@@ -18,7 +18,6 @@ package bind_test
 
 import (
 	"context"
-	"errors"
 	"math/big"
 	"testing"
 	"time"
@@ -57,10 +56,8 @@ func TestWaitDeployed(t *testing.T) {
 		backend := backends.NewSimulatedBackend(
 			core.GenesisAlloc{
 				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000)},
-			},
-			10000000,
+			}, 10000000,
 		)
-		defer backend.Close()
 
 		// Create the transaction.
 		tx := types.NewContractCreation(0, big.NewInt(0), test.gas, big.NewInt(1), common.FromHex(test.code))
@@ -85,7 +82,7 @@ func TestWaitDeployed(t *testing.T) {
 		select {
 		case <-mined:
 			if err != test.wantErr {
-				t.Errorf("test %q: error mismatch: want %q, got %q", name, test.wantErr, err)
+				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())
@@ -95,40 +92,3 @@ func TestWaitDeployed(t *testing.T) {
 		}
 	}
 }
-
-func TestWaitDeployedCornerCases(t *testing.T) {
-	backend := backends.NewSimulatedBackend(
-		core.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000)},
-		},
-		10000000,
-	)
-	defer backend.Close()
-
-	// Create a transaction to an account.
-	code := "6060604052600a8060106000396000f360606040526008565b00"
-	tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, big.NewInt(1), common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	backend.SendTransaction(ctx, tx)
-	backend.Commit()
-	notContentCreation := errors.New("tx is not contract creation")
-	if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != notContentCreation.Error() {
-		t.Errorf("error missmatch: want %q, got %q, ", notContentCreation, err)
-	}
-
-	// Create a transaction that is not mined.
-	tx = types.NewContractCreation(1, big.NewInt(0), 3000000, big.NewInt(1), common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.HomesteadSigner{}, testKey)
-
-	go func() {
-		contextCanceled := errors.New("context canceled")
-		if _, err := bind.WaitDeployed(ctx, backend, tx); err.Error() != contextCanceled.Error() {
-			t.Errorf("error missmatch: want %q, got %q, ", contextCanceled, err)
-		}
-	}()
-
-	backend.SendTransaction(ctx, tx)
-	cancel()
-}

accounts/abi/error.go

@@ -39,21 +39,23 @@ func formatSliceString(kind reflect.Kind, sliceSize int) string {
 // type in t.
 func sliceTypeCheck(t Type, val reflect.Value) error {
 	if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
-		return typeErr(formatSliceString(t.GetType().Kind(), t.Size), val.Type())
+		return typeErr(formatSliceString(t.Kind, t.Size), val.Type())
 	}
 
 	if t.T == ArrayTy && val.Len() != t.Size {
-		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len()))
+		return typeErr(formatSliceString(t.Elem.Kind, t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len()))
 	}
 
-	if t.Elem.T == SliceTy || t.Elem.T == ArrayTy {
+	if t.Elem.T == SliceTy {
 		if val.Len() > 0 {
 			return sliceTypeCheck(*t.Elem, val.Index(0))
 		}
+	} else if t.Elem.T == ArrayTy {
+		return sliceTypeCheck(*t.Elem, val.Index(0))
 	}
 
-	if val.Type().Elem().Kind() != t.Elem.GetType().Kind() {
-		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), val.Type())
+	if elemKind := val.Type().Elem().Kind(); elemKind != t.Elem.Kind {
+		return typeErr(formatSliceString(t.Elem.Kind, t.Size), val.Type())
 	}
 	return nil
 }
@@ -66,10 +68,10 @@ func typeCheck(t Type, value reflect.Value) error {
 	}
 
 	// Check base type validity. Element types will be checked later on.
-	if t.GetType().Kind() != value.Kind() {
-		return typeErr(t.GetType().Kind(), value.Kind())
+	if t.Kind != value.Kind() {
+		return typeErr(t.Kind, value.Kind())
 	} else if t.T == FixedBytesTy && t.Size != value.Len() {
-		return typeErr(t.GetType(), value.Type())
+		return typeErr(t.Type, value.Type())
 	} else {
 		return nil
 	}

accounts/abi/event.go

@@ -28,73 +28,30 @@ import (
 // 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.
-	// These are two events that have the 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
-	str       string
-	// Sig contains the string signature according to the ABI spec.
-	// e.g.	 event foo(uint32 a, int b) = "foo(uint32,int256)"
-	// Please note that "int" is substitute for its canonical representation "int256"
-	Sig string
-	// ID returns the canonical representation of the event's signature used by the
-	// abi definition to identify event names and types.
-	ID common.Hash
-}
-
-// NewEvent creates a new Event.
-// It sanitizes the input arguments to remove unnamed arguments.
-// It also precomputes the id, signature and string representation
-// of the event.
-func NewEvent(name, rawName string, anonymous bool, inputs Arguments) Event {
-	// sanitize inputs to remove inputs without names
-	// and precompute string and sig representation.
-	names := make([]string, len(inputs))
-	types := make([]string, len(inputs))
-	for i, input := range inputs {
-		if input.Name == "" {
-			inputs[i] = Argument{
-				Name:    fmt.Sprintf("arg%d", i),
-				Indexed: input.Indexed,
-				Type:    input.Type,
-			}
-		} else {
-			inputs[i] = input
-		}
-		// string representation
-		names[i] = fmt.Sprintf("%v %v", input.Type, inputs[i].Name)
-		if input.Indexed {
-			names[i] = fmt.Sprintf("%v indexed %v", input.Type, inputs[i].Name)
-		}
-		// sig representation
-		types[i] = input.Type.String()
-	}
-
-	str := fmt.Sprintf("event %v(%v)", rawName, strings.Join(names, ", "))
-	sig := fmt.Sprintf("%v(%v)", rawName, strings.Join(types, ","))
-	id := common.BytesToHash(crypto.Keccak256([]byte(sig)))
-
-	return Event{
-		Name:      name,
-		RawName:   rawName,
-		Anonymous: anonymous,
-		Inputs:    inputs,
-		str:       str,
-		Sig:       sig,
-		ID:        id,
-	}
 }
 
 func (e Event) String() string {
-	return e.str
+	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.Name, strings.Join(inputs, ", "))
+}
+
+// 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 {
+	types := make([]string, len(e.Inputs))
+	i := 0
+	for _, input := range e.Inputs {
+		types[i] = input.Type.String()
+		i++
+	}
+	return common.BytesToHash(crypto.Keccak256([]byte(fmt.Sprintf("%v(%v)", e.Name, strings.Join(types, ",")))))
 }

accounts/abi/event_test.go

@@ -104,8 +104,8 @@ func TestEventId(t *testing.T) {
 		}
 
 		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)
+			if event.Id() != test.expectations[name] {
+				t.Errorf("expected id to be %x, got %x", test.expectations[name], event.Id())
 			}
 		}
 	}
@@ -147,6 +147,10 @@ func TestEventString(t *testing.T) {
 // 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
@@ -154,10 +158,10 @@ func TestEventMultiValueWithArrayUnpack(t *testing.T) {
 	for ; i <= 3; i++ {
 		b.Write(packNum(reflect.ValueOf(i)))
 	}
-	unpacked, err := abi.Unpack("test", b.Bytes())
-	require.NoError(t, err)
-	require.Equal(t, [2]uint8{1, 2}, unpacked[0])
-	require.Equal(t, uint8(3), unpacked[1])
+	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) {
@@ -169,7 +173,7 @@ func TestEventTupleUnpack(t *testing.T) {
 	type EventTransferWithTag struct {
 		// this is valid because `value` is not exportable,
 		// so value is only unmarshalled into `Value1`.
-		value  *big.Int //lint:ignore U1000 unused field is part of test
+		value  *big.Int
 		Value1 *big.Int `abi:"value"`
 	}
 
@@ -308,14 +312,14 @@ func TestEventTupleUnpack(t *testing.T) {
 		&[]interface{}{common.Address{}, new(big.Int)},
 		&[]interface{}{},
 		jsonEventPledge,
-		"abi: insufficient number of arguments for unpack, want 3, got 2",
+		"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:[2] cannot unmarshal tuple in to map[string]interface {}",
+		"abi: cannot unmarshal tuple into map[string]interface {}",
 		"Can not unpack Pledge event into map",
 	}, {
 		mixedCaseData1,
@@ -347,14 +351,48 @@ func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, ass
 	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.UnpackIntoInterface(dest, "e", data)
+	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 // indexed
+		Value1 uint8
 		Value2 uint8
 	}
 	abi, err := JSON(strings.NewReader(definition))
@@ -362,16 +400,16 @@ func TestEventUnpackIndexed(t *testing.T) {
 	var b bytes.Buffer
 	b.Write(packNum(reflect.ValueOf(uint8(8))))
 	var rst testStruct
-	require.NoError(t, abi.UnpackIntoInterface(&rst, "test", b.Bytes()))
+	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 overflow when static array is indexed input.
+// 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 // indexed
+		Value1 [2]uint8
 		Value2 string
 	}
 	abi, err := JSON(strings.NewReader(definition))
@@ -384,7 +422,7 @@ func TestEventIndexedWithArrayUnpack(t *testing.T) {
 	b.Write(common.RightPadBytes([]byte(stringOut), 32))
 
 	var rst testStruct
-	require.NoError(t, abi.UnpackIntoInterface(&rst, "test", b.Bytes()))
+	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
 	require.Equal(t, [2]uint8{0, 0}, rst.Value1)
 	require.Equal(t, stringOut, rst.Value2)
 }

accounts/abi/method.go

@@ -23,145 +23,55 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
-// FunctionType represents different types of functions a contract might have.
-type FunctionType int
-
-const (
-	// Constructor represents the constructor of the contract.
-	// The constructor function is called while deploying a contract.
-	Constructor FunctionType = iota
-	// Fallback represents the fallback function.
-	// This function is executed if no other function matches the given function
-	// signature and no receive function is specified.
-	Fallback
-	// Receive represents the receive function.
-	// This function is executed on plain Ether transfers.
-	Receive
-	// Function represents a normal function.
-	Function
-)
-
 // 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 sent to the
+// from the storage and therefor requires no Tx to be send to the
 // network. A method such as `Transact` does require a Tx and thus will
-// be flagged `false`.
+// be flagged `true`.
 // 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.
-	// These are two functions that have the 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 string // RawName is the raw method name parsed from ABI
-
-	// Type indicates whether the method is a
-	// special fallback introduced in solidity v0.6.0
-	Type FunctionType
-
-	// StateMutability indicates the mutability state of method,
-	// the default value is nonpayable. It can be empty if the abi
-	// is generated by legacy compiler.
-	StateMutability string
-
-	// Legacy indicators generated by compiler before v0.6.0
-	Constant bool
-	Payable  bool
-
+	Const   bool
 	Inputs  Arguments
 	Outputs Arguments
-	str     string
-	// Sig returns the methods string signature according to the ABI spec.
-	// e.g.		function foo(uint32 a, int b) = "foo(uint32,int256)"
-	// Please note that "int" is substitute for its canonical representation "int256"
-	Sig string
-	// ID returns the canonical representation of the method's signature used by the
-	// abi definition to identify method names and types.
-	ID []byte
 }
 
-// NewMethod creates a new Method.
-// A method should always be created using NewMethod.
-// It also precomputes the sig representation and the string representation
-// of the method.
-func NewMethod(name string, rawName string, funType FunctionType, mutability string, isConst, isPayable bool, inputs Arguments, outputs Arguments) Method {
-	var (
-		types       = make([]string, len(inputs))
-		inputNames  = make([]string, len(inputs))
-		outputNames = make([]string, len(outputs))
-	)
-	for i, input := range inputs {
-		inputNames[i] = fmt.Sprintf("%v %v", input.Type, input.Name)
+// 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()
 	}
-	for i, output := range outputs {
-		outputNames[i] = output.Type.String()
-		if len(output.Name) > 0 {
-			outputNames[i] += fmt.Sprintf(" %v", output.Name)
-		}
-	}
-	// calculate the signature and method id. Note only function
-	// has meaningful signature and id.
-	var (
-		sig string
-		id  []byte
-	)
-	if funType == Function {
-		sig = fmt.Sprintf("%v(%v)", rawName, strings.Join(types, ","))
-		id = crypto.Keccak256([]byte(sig))[:4]
-	}
-	// Extract meaningful state mutability of solidity method.
-	// If it's default value, never print it.
-	state := mutability
-	if state == "nonpayable" {
-		state = ""
-	}
-	if state != "" {
-		state = state + " "
-	}
-	identity := fmt.Sprintf("function %v", rawName)
-	if funType == Fallback {
-		identity = "fallback"
-	} else if funType == Receive {
-		identity = "receive"
-	} else if funType == Constructor {
-		identity = "constructor"
-	}
-	str := fmt.Sprintf("%v(%v) %sreturns(%v)", identity, strings.Join(inputNames, ", "), state, strings.Join(outputNames, ", "))
-
-	return Method{
-		Name:            name,
-		RawName:         rawName,
-		Type:            funType,
-		StateMutability: mutability,
-		Constant:        isConst,
-		Payable:         isPayable,
-		Inputs:          inputs,
-		Outputs:         outputs,
-		str:             str,
-		Sig:             sig,
-		ID:              id,
-	}
+	return fmt.Sprintf("%v(%v)", method.Name, strings.Join(types, ","))
 }
 
 func (method Method) String() string {
-	return method.str
+	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.Name, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", "))
 }
 
-// IsConstant returns the indicator whether the method is read-only.
-func (method Method) IsConstant() bool {
-	return method.StateMutability == "view" || method.StateMutability == "pure" || method.Constant
-}
-
-// IsPayable returns the indicator whether the method can process
-// plain ether transfers.
-func (method Method) IsPayable() bool {
-	return method.StateMutability == "payable" || method.Payable
+func (method Method) Id() []byte {
+	return crypto.Keccak256([]byte(method.Sig()))[:4]
 }

accounts/abi/method_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The go-ethereum Authors
+// 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
@@ -23,15 +23,9 @@ import (
 
 const methoddata = `
 [
-	{"type": "function", "name": "balance", "stateMutability": "view"},
-	{"type": "function", "name": "send", "inputs": [{ "name": "amount", "type": "uint256" }]},
-	{"type": "function", "name": "transfer", "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"},
-	{"stateMutability":"nonpayable","type":"fallback"},
-	{"stateMutability":"payable","type":"receive"}
+	{ "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" } ]  }
 ]`
 
 func TestMethodString(t *testing.T) {
@@ -41,7 +35,7 @@ func TestMethodString(t *testing.T) {
 	}{
 		{
 			method:      "balance",
-			expectation: "function balance() view returns()",
+			expectation: "function balance() constant returns()",
 		},
 		{
 			method:      "send",
@@ -51,30 +45,6 @@ func TestMethodString(t *testing.T) {
 			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()",
-		},
-		{
-			method:      "fallback",
-			expectation: "fallback() returns()",
-		},
-		{
-			method:      "receive",
-			expectation: "receive() payable returns()",
-		},
 	}
 
 	abi, err := JSON(strings.NewReader(methoddata))
@@ -83,63 +53,9 @@ func TestMethodString(t *testing.T) {
 	}
 
 	for _, test := range table {
-		var got string
-		if test.method == "fallback" {
-			got = abi.Fallback.String()
-		} else if test.method == "receive" {
-			got = abi.Receive.String()
-		} else {
-			got = abi.Methods[test.method].String()
-		}
+		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)
-		}
-	}
-}

accounts/abi/numbers.go

@@ -0,0 +1,44 @@
+// 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 (
+	"math/big"
+	"reflect"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/math"
+)
+
+var (
+	bigT      = reflect.TypeOf(&big.Int{})
+	derefbigT = reflect.TypeOf(big.Int{})
+	uint8T    = reflect.TypeOf(uint8(0))
+	uint16T   = reflect.TypeOf(uint16(0))
+	uint32T   = reflect.TypeOf(uint32(0))
+	uint64T   = reflect.TypeOf(uint64(0))
+	int8T     = reflect.TypeOf(int8(0))
+	int16T    = reflect.TypeOf(int16(0))
+	int32T    = reflect.TypeOf(int32(0))
+	int64T    = reflect.TypeOf(int64(0))
+	addressT  = reflect.TypeOf(common.Address{})
+)
+
+// U256 converts a big Int into a 256bit EVM number.
+func U256(n *big.Int) []byte {
+	return math.PaddedBigBytes(math.U256(n), 32)
+}

accounts/abi/numbers_test.go

@@ -0,0 +1,33 @@
+// 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)
+	}
+}

accounts/abi/pack.go

@@ -17,8 +17,6 @@
 package abi
 
 import (
-	"errors"
-	"fmt"
 	"math/big"
 	"reflect"
 
@@ -27,7 +25,7 @@ import (
 )
 
 // packBytesSlice packs the given bytes as [L, V] as the canonical representation
-// bytes slice.
+// bytes slice
 func packBytesSlice(bytes []byte, l int) []byte {
 	len := packNum(reflect.ValueOf(l))
 	return append(len, common.RightPadBytes(bytes, (l+31)/32*32)...)
@@ -35,51 +33,49 @@ func packBytesSlice(bytes []byte, l int) []byte {
 
 // packElement packs the given reflect value according to the abi specification in
 // t.
-func packElement(t Type, reflectValue reflect.Value) ([]byte, error) {
+func packElement(t Type, reflectValue reflect.Value) []byte {
 	switch t.T {
 	case IntTy, UintTy:
-		return packNum(reflectValue), nil
+		return packNum(reflectValue)
 	case StringTy:
-		return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len()), nil
+		return packBytesSlice([]byte(reflectValue.String()), reflectValue.Len())
 	case AddressTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
 
-		return common.LeftPadBytes(reflectValue.Bytes(), 32), nil
+		return common.LeftPadBytes(reflectValue.Bytes(), 32)
 	case BoolTy:
 		if reflectValue.Bool() {
-			return math.PaddedBigBytes(common.Big1, 32), nil
+			return math.PaddedBigBytes(common.Big1, 32)
 		}
-		return math.PaddedBigBytes(common.Big0, 32), nil
+		return math.PaddedBigBytes(common.Big0, 32)
 	case BytesTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
-		if reflectValue.Type() != reflect.TypeOf([]byte{}) {
-			return []byte{}, errors.New("Bytes type is neither slice nor array")
-		}
-		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len()), nil
+		return packBytesSlice(reflectValue.Bytes(), reflectValue.Len())
 	case FixedBytesTy, FunctionTy:
 		if reflectValue.Kind() == reflect.Array {
 			reflectValue = mustArrayToByteSlice(reflectValue)
 		}
-		return common.RightPadBytes(reflectValue.Bytes(), 32), nil
-	default:
-		return []byte{}, fmt.Errorf("Could not pack element, unknown type: %v", t.T)
-	}
-}
-
-// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation.
-func packNum(value reflect.Value) []byte {
-	switch kind := value.Kind(); kind {
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return math.U256Bytes(new(big.Int).SetUint64(value.Uint()))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return math.U256Bytes(big.NewInt(value.Int()))
-	case reflect.Ptr:
-		return math.U256Bytes(new(big.Int).Set(value.Interface().(*big.Int)))
+		return common.RightPadBytes(reflectValue.Bytes(), 32)
 	default:
 		panic("abi: fatal error")
 	}
 }
+
+// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation
+func packNum(value reflect.Value) []byte {
+	switch kind := value.Kind(); kind {
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return U256(new(big.Int).SetUint64(value.Uint()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return U256(big.NewInt(value.Int()))
+	case reflect.Ptr:
+		return U256(value.Interface().(*big.Int))
+	default:
+		panic("abi: fatal error")
+	}
+
+}

accounts/abi/pack_test.go

@@ -18,51 +18,623 @@ package abi
 
 import (
 	"bytes"
-	"encoding/hex"
-	"fmt"
 	"math"
 	"math/big"
 	"reflect"
-	"strconv"
 	"strings"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 )
 
-// TestPack tests the general pack/unpack tests in packing_test.go
 func TestPack(t *testing.T) {
-	for i, test := range packUnpackTests {
-		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			encb, err := hex.DecodeString(test.packed)
-			if err != nil {
-				t.Fatalf("invalid hex %s: %v", test.packed, err)
-			}
-			inDef := fmt.Sprintf(`[{ "name" : "method", "type": "function", "inputs": %s}]`, test.def)
-			inAbi, err := JSON(strings.NewReader(inDef))
-			if err != nil {
-				t.Fatalf("invalid ABI definition %s, %v", inDef, err)
-			}
-			var packed []byte
-			packed, err = inAbi.Pack("method", test.unpacked)
+	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("test %d (%v) failed: %v", i, test.def, err)
+			t.Fatalf("%v failed. Unexpected parse error: %v", i, err)
 		}
-			if !reflect.DeepEqual(packed[4:], encb) {
-				t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, encb, packed[4:])
+		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(jsondata))
+	abi, err := JSON(strings.NewReader(jsondata2))
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	sig := abi.Methods["slice"].ID
+	sig := abi.Methods["slice"].Id()
 	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
 	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
 
@@ -76,7 +648,7 @@ func TestMethodPack(t *testing.T) {
 	}
 
 	var addrA, addrB = common.Address{1}, common.Address{2}
-	sig = abi.Methods["sliceAddress"].ID
+	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)...)
@@ -91,7 +663,7 @@ func TestMethodPack(t *testing.T) {
 	}
 
 	var addrC, addrD = common.Address{3}, common.Address{4}
-	sig = abi.Methods["sliceMultiAddress"].ID
+	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)...)
@@ -109,7 +681,7 @@ func TestMethodPack(t *testing.T) {
 		t.Errorf("expected %x got %x", sig, packed)
 	}
 
-	sig = abi.Methods["slice256"].ID
+	sig = abi.Methods["slice256"].Id()
 	sig = append(sig, common.LeftPadBytes([]byte{1}, 32)...)
 	sig = append(sig, common.LeftPadBytes([]byte{2}, 32)...)
 
@@ -123,7 +695,7 @@ func TestMethodPack(t *testing.T) {
 	}
 
 	a := [2][2]*big.Int{{big.NewInt(1), big.NewInt(1)}, {big.NewInt(2), big.NewInt(0)}}
-	sig = abi.Methods["nestedArray"].ID
+	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)...)
@@ -140,7 +712,7 @@ func TestMethodPack(t *testing.T) {
 		t.Errorf("expected %x got %x", sig, packed)
 	}
 
-	sig = abi.Methods["nestedArray2"].ID
+	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)...)
@@ -156,7 +728,7 @@ func TestMethodPack(t *testing.T) {
 		t.Errorf("expected %x got %x", sig, packed)
 	}
 
-	sig = abi.Methods["nestedSlice"].ID
+	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)...)

accounts/abi/packing_test.go

@@ -1,990 +0,0 @@
-// Copyright 2020 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"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-type packUnpackTest struct {
-	def      string
-	unpacked interface{}
-	packed   string
-}
-
-var packUnpackTests = []packUnpackTest{
-	// Booleans
-	{
-		def:      `[{ "type": "bool" }]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: true,
-	},
-	{
-		def:      `[{ "type": "bool" }]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: false,
-	},
-	// Integers
-	{
-		def:      `[{ "type": "uint8" }]`,
-		unpacked: uint8(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{ "type": "uint8[]" }]`,
-		unpacked: []uint8{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{ "type": "uint16" }]`,
-		unpacked: uint16(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{ "type": "uint16[]" }]`,
-		unpacked: []uint16{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "uint17"}]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: big.NewInt(1),
-	},
-	{
-		def:      `[{"type": "uint32"}]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: uint32(1),
-	},
-	{
-		def:      `[{"type": "uint32[]"}]`,
-		unpacked: []uint32{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "uint64"}]`,
-		unpacked: uint64(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "uint64[]"}]`,
-		unpacked: []uint64{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "uint256"}]`,
-		unpacked: big.NewInt(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "uint256[]"}]`,
-		unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int8"}]`,
-		unpacked: int8(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int8[]"}]`,
-		unpacked: []int8{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int16"}]`,
-		unpacked: int16(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int16[]"}]`,
-		unpacked: []int16{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int17"}]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: big.NewInt(1),
-	},
-	{
-		def:      `[{"type": "int32"}]`,
-		unpacked: int32(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int32"}]`,
-		packed:   "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: int32(1),
-	},
-	{
-		def:      `[{"type": "int32[]"}]`,
-		unpacked: []int32{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int64"}]`,
-		unpacked: int64(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int64[]"}]`,
-		unpacked: []int64{1, 2},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int256"}]`,
-		unpacked: big.NewInt(2),
-		packed:   "0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	{
-		def:      `[{"type": "int256"}]`,
-		packed:   "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-		unpacked: big.NewInt(-1),
-	},
-	{
-		def:      `[{"type": "int256[]"}]`,
-		unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-	},
-	// Address
-	{
-		def:      `[{"type": "address"}]`,
-		packed:   "0000000000000000000000000100000000000000000000000000000000000000",
-		unpacked: common.Address{1},
-	},
-	{
-		def:      `[{"type": "address[]"}]`,
-		unpacked: []common.Address{{1}, {2}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000100000000000000000000000000000000000000" +
-			"0000000000000000000000000200000000000000000000000000000000000000",
-	},
-	// Bytes
-	{
-		def:      `[{"type": "bytes1"}]`,
-		unpacked: [1]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes2"}]`,
-		unpacked: [2]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes3"}]`,
-		unpacked: [3]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes4"}]`,
-		unpacked: [4]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes5"}]`,
-		unpacked: [5]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes6"}]`,
-		unpacked: [6]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes7"}]`,
-		unpacked: [7]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes8"}]`,
-		unpacked: [8]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes9"}]`,
-		unpacked: [9]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes10"}]`,
-		unpacked: [10]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes11"}]`,
-		unpacked: [11]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes12"}]`,
-		unpacked: [12]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes13"}]`,
-		unpacked: [13]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes14"}]`,
-		unpacked: [14]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes15"}]`,
-		unpacked: [15]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes16"}]`,
-		unpacked: [16]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes17"}]`,
-		unpacked: [17]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes18"}]`,
-		unpacked: [18]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes19"}]`,
-		unpacked: [19]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes20"}]`,
-		unpacked: [20]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes21"}]`,
-		unpacked: [21]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes22"}]`,
-		unpacked: [22]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes23"}]`,
-		unpacked: [23]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes24"}]`,
-		unpacked: [24]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes25"}]`,
-		unpacked: [25]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes26"}]`,
-		unpacked: [26]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes27"}]`,
-		unpacked: [27]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes28"}]`,
-		unpacked: [28]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes29"}]`,
-		unpacked: [29]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes30"}]`,
-		unpacked: [30]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes31"}]`,
-		unpacked: [31]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes32"}]`,
-		unpacked: [32]byte{1},
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "bytes32"}]`,
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-	},
-	{
-		def: `[{"type": "bytes"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000020" +
-			"0100000000000000000000000000000000000000000000000000000000000000",
-		unpacked: common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
-	},
-	{
-		def:      `[{"type": "bytes32"}]`,
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-	},
-	// Functions
-	{
-		def:      `[{"type": "function"}]`,
-		packed:   "0100000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [24]byte{1},
-	},
-	// Slice and Array
-	{
-		def: `[{"type": "uint8[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []uint8{1, 2},
-	},
-	{
-		def: `[{"type": "uint8[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: []uint8{},
-	},
-	{
-		def: `[{"type": "uint256[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: []*big.Int{},
-	},
-	{
-		def: `[{"type": "uint8[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]uint8{1, 2},
-	},
-	{
-		def: `[{"type": "int8[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]int8{1, 2},
-	},
-	{
-		def: `[{"type": "int16[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []int16{1, 2},
-	},
-	{
-		def: `[{"type": "int16[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]int16{1, 2},
-	},
-	{
-		def: `[{"type": "int32[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []int32{1, 2},
-	},
-	{
-		def: `[{"type": "int32[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]int32{1, 2},
-	},
-	{
-		def: `[{"type": "int64[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []int64{1, 2},
-	},
-	{
-		def: `[{"type": "int64[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]int64{1, 2},
-	},
-	{
-		def: `[{"type": "int256[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
-	},
-	{
-		def: `[{"type": "int256[3]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000003",
-		unpacked: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
-	},
-	// multi dimensional, if these pass, all types that don't require length prefix should pass
-	{
-		def: `[{"type": "uint8[][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [][]uint8{},
-	},
-	{
-		def: `[{"type": "uint8[][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"00000000000000000000000000000000000000000000000000000000000000a0" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [][]uint8{{1, 2}, {1, 2}},
-	},
-	{
-		def: `[{"type": "uint8[][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"00000000000000000000000000000000000000000000000000000000000000a0" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000003" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000003",
-		unpacked: [][]uint8{{1, 2}, {1, 2, 3}},
-	},
-	{
-		def: `[{"type": "uint8[2][2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2][2]uint8{{1, 2}, {1, 2}},
-	},
-	{
-		def: `[{"type": "uint8[][2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"0000000000000000000000000000000000000000000000000000000000000060" +
-			"0000000000000000000000000000000000000000000000000000000000000000" +
-			"0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [2][]uint8{{}, {}},
-	},
-	{
-		def: `[{"type": "uint8[][2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"0000000000000000000000000000000000000000000000000000000000000080" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: [2][]uint8{{1}, {1}},
-	},
-	{
-		def: `[{"type": "uint8[2][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000000",
-		unpacked: [][2]uint8{},
-	},
-	{
-		def: `[{"type": "uint8[2][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [][2]uint8{{1, 2}},
-	},
-	{
-		def: `[{"type": "uint8[2][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [][2]uint8{{1, 2}, {1, 2}},
-	},
-	{
-		def: `[{"type": "uint16[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []uint16{1, 2},
-	},
-	{
-		def: `[{"type": "uint16[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]uint16{1, 2},
-	},
-	{
-		def: `[{"type": "uint32[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []uint32{1, 2},
-	},
-	{
-		def:      `[{"type": "uint32[2][3][4]"}]`,
-		unpacked: [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}}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000003" +
-			"0000000000000000000000000000000000000000000000000000000000000004" +
-			"0000000000000000000000000000000000000000000000000000000000000005" +
-			"0000000000000000000000000000000000000000000000000000000000000006" +
-			"0000000000000000000000000000000000000000000000000000000000000007" +
-			"0000000000000000000000000000000000000000000000000000000000000008" +
-			"0000000000000000000000000000000000000000000000000000000000000009" +
-			"000000000000000000000000000000000000000000000000000000000000000a" +
-			"000000000000000000000000000000000000000000000000000000000000000b" +
-			"000000000000000000000000000000000000000000000000000000000000000c" +
-			"000000000000000000000000000000000000000000000000000000000000000d" +
-			"000000000000000000000000000000000000000000000000000000000000000e" +
-			"000000000000000000000000000000000000000000000000000000000000000f" +
-			"0000000000000000000000000000000000000000000000000000000000000010" +
-			"0000000000000000000000000000000000000000000000000000000000000011" +
-			"0000000000000000000000000000000000000000000000000000000000000012" +
-			"0000000000000000000000000000000000000000000000000000000000000013" +
-			"0000000000000000000000000000000000000000000000000000000000000014" +
-			"0000000000000000000000000000000000000000000000000000000000000015" +
-			"0000000000000000000000000000000000000000000000000000000000000016" +
-			"0000000000000000000000000000000000000000000000000000000000000017" +
-			"0000000000000000000000000000000000000000000000000000000000000018",
-	},
-
-	{
-		def:      `[{"type": "bytes32[]"}]`,
-		unpacked: [][32]byte{{1}, {2}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0100000000000000000000000000000000000000000000000000000000000000" +
-			"0200000000000000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def: `[{"type": "uint32[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]uint32{1, 2},
-	},
-	{
-		def: `[{"type": "uint64[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []uint64{1, 2},
-	},
-	{
-		def: `[{"type": "uint64[2]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: [2]uint64{1, 2},
-	},
-	{
-		def: `[{"type": "uint256[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: []*big.Int{big.NewInt(1), big.NewInt(2)},
-	},
-	{
-		def: `[{"type": "uint256[3]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000003",
-		unpacked: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
-	},
-	{
-		def: `[{"type": "string[4]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000080" +
-			"00000000000000000000000000000000000000000000000000000000000000c0" +
-			"0000000000000000000000000000000000000000000000000000000000000100" +
-			"0000000000000000000000000000000000000000000000000000000000000140" +
-			"0000000000000000000000000000000000000000000000000000000000000005" +
-			"48656c6c6f000000000000000000000000000000000000000000000000000000" +
-			"0000000000000000000000000000000000000000000000000000000000000005" +
-			"576f726c64000000000000000000000000000000000000000000000000000000" +
-			"000000000000000000000000000000000000000000000000000000000000000b" +
-			"476f2d657468657265756d000000000000000000000000000000000000000000" +
-			"0000000000000000000000000000000000000000000000000000000000000008" +
-			"457468657265756d000000000000000000000000000000000000000000000000",
-		unpacked: [4]string{"Hello", "World", "Go-ethereum", "Ethereum"},
-	},
-	{
-		def: `[{"type": "string[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"0000000000000000000000000000000000000000000000000000000000000080" +
-			"0000000000000000000000000000000000000000000000000000000000000008" +
-			"457468657265756d000000000000000000000000000000000000000000000000" +
-			"000000000000000000000000000000000000000000000000000000000000000b" +
-			"676f2d657468657265756d000000000000000000000000000000000000000000",
-		unpacked: []string{"Ethereum", "go-ethereum"},
-	},
-	{
-		def: `[{"type": "bytes[]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"0000000000000000000000000000000000000000000000000000000000000080" +
-			"0000000000000000000000000000000000000000000000000000000000000003" +
-			"f0f0f00000000000000000000000000000000000000000000000000000000000" +
-			"0000000000000000000000000000000000000000000000000000000000000003" +
-			"f0f0f00000000000000000000000000000000000000000000000000000000000",
-		unpacked: [][]byte{{0xf0, 0xf0, 0xf0}, {0xf0, 0xf0, 0xf0}},
-	},
-	{
-		def: `[{"type": "uint256[2][][]"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000040" +
-			"00000000000000000000000000000000000000000000000000000000000000e0" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"00000000000000000000000000000000000000000000000000000000000000c8" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"00000000000000000000000000000000000000000000000000000000000003e8" +
-			"0000000000000000000000000000000000000000000000000000000000000002" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"00000000000000000000000000000000000000000000000000000000000000c8" +
-			"0000000000000000000000000000000000000000000000000000000000000001" +
-			"00000000000000000000000000000000000000000000000000000000000003e8",
-		unpacked: [][][2]*big.Int{{{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}, {{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}},
-	},
-	// struct outputs
-	{
-		def: `[{"components": [{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}], "type":"tuple"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: struct {
-			Int1 *big.Int
-			Int2 *big.Int
-		}{big.NewInt(1), big.NewInt(2)},
-	},
-	{
-		def:    `[{"components": [{"name":"int_one","type":"int256"}], "type":"tuple"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
-	{
-		def:    `[{"components": [{"name":"int__one","type":"int256"}], "type":"tuple"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
-	{
-		def:    `[{"components": [{"name":"int_one_","type":"int256"}], "type":"tuple"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001",
-		unpacked: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
-	{
-		def: `[{"components": [{"name":"int_one","type":"int256"}, {"name":"intone","type":"int256"}], "type":"tuple"}]`,
-		packed: "0000000000000000000000000000000000000000000000000000000000000001" +
-			"0000000000000000000000000000000000000000000000000000000000000002",
-		unpacked: struct {
-			IntOne *big.Int
-			Intone *big.Int
-		}{big.NewInt(1), big.NewInt(2)},
-	},
-	{
-		def:      `[{"type": "string"}]`,
-		unpacked: "foobar",
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"0000000000000000000000000000000000000000000000000000000000000006" +
-			"666f6f6261720000000000000000000000000000000000000000000000000000",
-	},
-	{
-		def:      `[{"type": "string[]"}]`,
-		unpacked: []string{"hello", "foobar"},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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]
-	},
-	{
-		def:      `[{"type": "string[2]"}]`,
-		unpacked: [2]string{"hello", "foobar"},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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]
-	},
-	{
-		def:      `[{"type": "bytes32[][]"}]`,
-		unpacked: [][][32]byte{{{1}, {2}}, {{3}, {4}, {5}}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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]
-	},
-	{
-		def:      `[{"type": "bytes32[][2]"}]`,
-		unpacked: [2][][32]byte{{{1}, {2}}, {{3}, {4}, {5}}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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]
-	},
-	{
-		def:      `[{"type": "bytes32[3][2]"}]`,
-		unpacked: [2][3][32]byte{{{1}, {2}, {3}}, {{3}, {4}, {5}}},
-		packed: "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
-		def: `[{"components": [{"name":"a","type":"int64"}, 
-		{"name":"b","type":"int256"}, 
-		{"name":"c","type":"int256"}, 
-		{"name":"d","type":"bool"},
-		{"name":"e","type":"bytes32[3][2]"}], "type":"tuple"}]`,
-		unpacked: struct {
-			A int64
-			B *big.Int
-			C *big.Int
-			D bool
-			E [2][3][32]byte
-		}{1, big.NewInt(1), big.NewInt(-1), true, [2][3][32]byte{{{1}, {2}, {3}}, {{3}, {4}, {5}}}},
-		packed: "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]
-	},
-	{
-		def: `[{"components": [{"name":"a","type":"string"}, 
-		{"name":"b","type":"int64"}, 
-		{"name":"c","type":"bytes"}, 
-		{"name":"d","type":"string[]"},
-		{"name":"e","type":"int256[]"},
-		{"name":"f","type":"address[]"}], "type":"tuple"}]`,
-		unpacked: struct {
-			A string
-			B int64
-			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}}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
-			"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}
-	},
-	{
-		def: `[{"components": [{ "type": "tuple","components": [{"name": "a","type": "uint256"},	
-							{"name": "b","type": "uint256[]"}],	
-							"name": "a","type": "tuple"},
-							{"name": "b","type": "uint256[]"}],  "type": "tuple"}]`,
-		unpacked: struct {
-			A struct {
-				A *big.Int
-				B []*big.Int
-			}
-			B []*big.Int
-		}{
-			A: struct {
-				A *big.Int
-				B []*big.Int
-			}{big.NewInt(1), []*big.Int{big.NewInt(1), big.NewInt(2)}},
-			B: []*big.Int{big.NewInt(1), big.NewInt(2)}},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" + // struct a
-			"0000000000000000000000000000000000000000000000000000000000000040" + // a offset
-			"00000000000000000000000000000000000000000000000000000000000000e0" + // b offset
-			"0000000000000000000000000000000000000000000000000000000000000001" + // a.a value
-			"0000000000000000000000000000000000000000000000000000000000000040" + // a.b offset
-			"0000000000000000000000000000000000000000000000000000000000000002" + // a.b length
-			"0000000000000000000000000000000000000000000000000000000000000001" + // a.b[0] value
-			"0000000000000000000000000000000000000000000000000000000000000002" + // a.b[1] value
-			"0000000000000000000000000000000000000000000000000000000000000002" + // b length
-			"0000000000000000000000000000000000000000000000000000000000000001" + // b[0] value
-			"0000000000000000000000000000000000000000000000000000000000000002", // b[1] value
-	},
-
-	{
-		def: `[{"components": [{"name": "a","type": "int256"},	
-							{"name": "b","type": "int256[]"}],	
-							"name": "a","type": "tuple[]"}]`,
-		unpacked: []struct {
-			A *big.Int
-			B []*big.Int
-		}{
-			{big.NewInt(-1), []*big.Int{big.NewInt(1), big.NewInt(3)}},
-			{big.NewInt(1), []*big.Int{big.NewInt(2), big.NewInt(-1)}},
-		},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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
-			"0000000000000000000000000000000000000000000000000000000000000003" + // 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
-	},
-	{
-		def: `[{"components": [{"name": "a","type": "int256"},	
-							{"name": "b","type": "int256"}],	
-							"name": "a","type": "tuple[2]"}]`,
-		unpacked: [2]struct {
-			A *big.Int
-			B *big.Int
-		}{
-			{big.NewInt(-1), big.NewInt(1)},
-			{big.NewInt(1), big.NewInt(-1)},
-		},
-		packed: "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + // tuple[0].a
-			"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[0].b
-			"0000000000000000000000000000000000000000000000000000000000000001" + // tuple[1].a
-			"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", // tuple[1].b
-	},
-	{
-		def: `[{"components": [{"name": "a","type": "int256[]"}],
-							"name": "a","type": "tuple[2]"}]`,
-		unpacked: [2]struct {
-			A []*big.Int
-		}{
-			{[]*big.Int{big.NewInt(-1), big.NewInt(1)}},
-			{[]*big.Int{big.NewInt(1), big.NewInt(-1)}},
-		},
-		packed: "0000000000000000000000000000000000000000000000000000000000000020" +
-			"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]
-	},
-}

accounts/abi/reflect.go

@@ -17,74 +17,49 @@
 package abi
 
 import (
-	"errors"
 	"fmt"
-	"math/big"
 	"reflect"
 	"strings"
 )
 
-// ConvertType converts an interface of a runtime type into a interface of the
-// given type
-// e.g. turn
-// var fields []reflect.StructField
-// fields = append(fields, reflect.StructField{
-// 		Name: "X",
-//		Type: reflect.TypeOf(new(big.Int)),
-//		Tag:  reflect.StructTag("json:\"" + "x" + "\""),
-// }
-// into
-// type TupleT struct { X *big.Int }
-func ConvertType(in interface{}, proto interface{}) interface{} {
-	protoType := reflect.TypeOf(proto)
-	if reflect.TypeOf(in).ConvertibleTo(protoType) {
-		return reflect.ValueOf(in).Convert(protoType).Interface()
-	}
-	// Use set as a last ditch effort
-	if err := set(reflect.ValueOf(proto), reflect.ValueOf(in)); err != nil {
-		panic(err)
-	}
-	return proto
-}
-
 // 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() != reflect.TypeOf(big.Int{}) {
+	if v.Kind() == reflect.Ptr && v.Elem().Type() != derefbigT {
 		return indirect(v.Elem())
 	}
 	return v
 }
 
-// reflectIntType returns the reflect using the given size and
+// reflectIntKind returns the reflect using the given size and
 // unsignedness.
-func reflectIntType(unsigned bool, size int) reflect.Type {
+func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) {
+	switch size {
+	case 8:
 		if unsigned {
-		switch size {
-		case 8:
-			return reflect.TypeOf(uint8(0))
+			return reflect.Uint8, uint8T
+		}
+		return reflect.Int8, int8T
 	case 16:
-			return reflect.TypeOf(uint16(0))
+		if unsigned {
+			return reflect.Uint16, uint16T
+		}
+		return reflect.Int16, int16T
 	case 32:
-			return reflect.TypeOf(uint32(0))
+		if unsigned {
+			return reflect.Uint32, uint32T
+		}
+		return reflect.Int32, int32T
 	case 64:
-			return reflect.TypeOf(uint64(0))
+		if unsigned {
+			return reflect.Uint64, uint64T
 		}
+		return reflect.Int64, int64T
 	}
-	switch size {
-	case 8:
-		return reflect.TypeOf(int8(0))
-	case 16:
-		return reflect.TypeOf(int16(0))
-	case 32:
-		return reflect.TypeOf(int32(0))
-	case 64:
-		return reflect.TypeOf(int64(0))
-	}
-	return reflect.TypeOf(&big.Int{})
+	return reflect.Ptr, bigT
 }
 
-// mustArrayToByteSlice creates a new byte slice with the exact same size as value
+// 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())
@@ -99,18 +74,14 @@ func mustArrayToByteSlice(value reflect.Value) reflect.Value {
 func set(dst, src reflect.Value) error {
 	dstType, srcType := dst.Type(), src.Type()
 	switch {
-	case dstType.Kind() == reflect.Interface && dst.Elem().IsValid():
+	case dstType.Kind() == reflect.Interface:
 		return set(dst.Elem(), src)
-	case dstType.Kind() == reflect.Ptr && dstType.Elem() != reflect.TypeOf(big.Int{}):
+	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 && dst.CanSet():
+	case dstType.Kind() == reflect.Slice && srcType.Kind() == reflect.Slice:
 		return setSlice(dst, src)
-	case dstType.Kind() == reflect.Array:
-		return setArray(dst, src)
-	case dstType.Kind() == reflect.Struct:
-		return setStruct(dst, src)
 	default:
 		return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
 	}
@@ -119,59 +90,38 @@ func set(dst, src reflect.Value) error {
 
 // setSlice attempts to assign src to dst when slices are not assignable by default
 // e.g. src: [][]byte -> dst: [][15]byte
-// setSlice ignores if we cannot copy all of src' elements.
 func setSlice(dst, src reflect.Value) error {
 	slice := reflect.MakeSlice(dst.Type(), src.Len(), src.Len())
 	for i := 0; i < src.Len(); i++ {
-		if src.Index(i).Kind() == reflect.Struct {
-			if err := set(slice.Index(i), src.Index(i)); err != nil {
-				return err
+		v := src.Index(i)
+		reflect.Copy(slice.Index(i), v)
 	}
-		} else {
-			// e.g. [][32]uint8 to []common.Hash
-			if err := set(slice.Index(i), src.Index(i)); err != nil {
-				return err
-			}
-		}
-	}
-	if dst.CanSet() {
+
 	dst.Set(slice)
 	return nil
-	}
-	return errors.New("Cannot set slice, destination not settable")
 }
 
-func setArray(dst, src reflect.Value) error {
-	if src.Kind() == reflect.Ptr {
-		return set(dst, indirect(src))
+// 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())
 	}
-	array := reflect.New(dst.Type()).Elem()
-	min := src.Len()
-	if src.Len() > dst.Len() {
-		min = dst.Len()
-	}
-	for i := 0; i < min; i++ {
-		if err := set(array.Index(i), src.Index(i)); err != nil {
-			return err
-		}
-	}
-	if dst.CanSet() {
-		dst.Set(array)
 	return nil
-	}
-	return errors.New("Cannot set array, destination not settable")
 }
 
-func setStruct(dst, src reflect.Value) error {
-	for i := 0; i < src.NumField(); i++ {
-		srcField := src.Field(i)
-		dstField := dst.Field(i)
-		if !dstField.IsValid() || !srcField.IsValid() {
-			return fmt.Errorf("Could not find src field: %v value: %v in destination", srcField.Type().Name(), srcField)
-		}
-		if err := set(dstField, srcField); err != nil {
-			return err
+// 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
 }
@@ -198,8 +148,9 @@ func mapArgNamesToStructFields(argNames []string, value reflect.Value) (map[stri
 			continue
 		}
 		// skip fields that have no abi:"" tag.
-		tagName, ok := typ.Field(i).Tag.Lookup("abi")
-		if !ok {
+		var ok bool
+		var tagName string
+		if tagName, ok = typ.Field(i).Tag.Lookup("abi"); !ok {
 			continue
 		}
 		// check if tag is empty.

accounts/abi/reflect_test.go

@@ -17,7 +17,6 @@
 package abi
 
 import (
-	"math/big"
 	"reflect"
 	"testing"
 )
@@ -190,72 +189,3 @@ func TestReflectNameToStruct(t *testing.T) {
 		})
 	}
 }
-
-func TestConvertType(t *testing.T) {
-	// Test Basic Struct
-	type T struct {
-		X *big.Int
-		Y *big.Int
-	}
-	// Create on-the-fly structure
-	var fields []reflect.StructField
-	fields = append(fields, reflect.StructField{
-		Name: "X",
-		Type: reflect.TypeOf(new(big.Int)),
-		Tag:  "json:\"" + "x" + "\"",
-	})
-	fields = append(fields, reflect.StructField{
-		Name: "Y",
-		Type: reflect.TypeOf(new(big.Int)),
-		Tag:  "json:\"" + "y" + "\"",
-	})
-	val := reflect.New(reflect.StructOf(fields))
-	val.Elem().Field(0).Set(reflect.ValueOf(big.NewInt(1)))
-	val.Elem().Field(1).Set(reflect.ValueOf(big.NewInt(2)))
-	// ConvertType
-	out := *ConvertType(val.Interface(), new(T)).(*T)
-	if out.X.Cmp(big.NewInt(1)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out.X, big.NewInt(1))
-	}
-	if out.Y.Cmp(big.NewInt(2)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out.Y, big.NewInt(2))
-	}
-	// Slice Type
-	val2 := reflect.MakeSlice(reflect.SliceOf(reflect.StructOf(fields)), 2, 2)
-	val2.Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
-	val2.Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
-	val2.Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
-	val2.Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
-	out2 := *ConvertType(val2.Interface(), new([]T)).(*[]T)
-	if out2[0].X.Cmp(big.NewInt(1)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
-	}
-	if out2[0].Y.Cmp(big.NewInt(2)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
-	}
-	if out2[1].X.Cmp(big.NewInt(3)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out2[0].X, big.NewInt(1))
-	}
-	if out2[1].Y.Cmp(big.NewInt(4)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out2[1].Y, big.NewInt(2))
-	}
-	// Array Type
-	val3 := reflect.New(reflect.ArrayOf(2, reflect.StructOf(fields)))
-	val3.Elem().Index(0).Field(0).Set(reflect.ValueOf(big.NewInt(1)))
-	val3.Elem().Index(0).Field(1).Set(reflect.ValueOf(big.NewInt(2)))
-	val3.Elem().Index(1).Field(0).Set(reflect.ValueOf(big.NewInt(3)))
-	val3.Elem().Index(1).Field(1).Set(reflect.ValueOf(big.NewInt(4)))
-	out3 := *ConvertType(val3.Interface(), new([2]T)).(*[2]T)
-	if out3[0].X.Cmp(big.NewInt(1)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
-	}
-	if out3[0].Y.Cmp(big.NewInt(2)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
-	}
-	if out3[1].X.Cmp(big.NewInt(3)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out3[0].X, big.NewInt(1))
-	}
-	if out3[1].Y.Cmp(big.NewInt(4)) != 0 {
-		t.Errorf("ConvertType failed, got %v want %v", out3[1].Y, big.NewInt(2))
-	}
-}

accounts/abi/topics.go

@@ -1,173 +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 (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math/big"
-	"reflect"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-// MakeTopics converts a filter query argument list into a filter topic set.
-func MakeTopics(query ...[]interface{}) ([][]common.Hash, error) {
-	topics := make([][]common.Hash, len(query))
-	for i, filter := range query {
-		for _, rule := range filter {
-			var topic common.Hash
-
-			// Try to generate the topic based on simple types
-			switch rule := rule.(type) {
-			case common.Hash:
-				copy(topic[:], rule[:])
-			case common.Address:
-				copy(topic[common.HashLength-common.AddressLength:], rule[:])
-			case *big.Int:
-				blob := rule.Bytes()
-				copy(topic[common.HashLength-len(blob):], blob)
-			case bool:
-				if rule {
-					topic[common.HashLength-1] = 1
-				}
-			case int8:
-				copy(topic[:], genIntType(int64(rule), 1))
-			case int16:
-				copy(topic[:], genIntType(int64(rule), 2))
-			case int32:
-				copy(topic[:], genIntType(int64(rule), 4))
-			case int64:
-				copy(topic[:], genIntType(rule, 8))
-			case uint8:
-				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
-				copy(topic[common.HashLength-len(blob):], blob)
-			case uint16:
-				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
-				copy(topic[common.HashLength-len(blob):], blob)
-			case uint32:
-				blob := new(big.Int).SetUint64(uint64(rule)).Bytes()
-				copy(topic[common.HashLength-len(blob):], blob)
-			case uint64:
-				blob := new(big.Int).SetUint64(rule).Bytes()
-				copy(topic[common.HashLength-len(blob):], blob)
-			case string:
-				hash := crypto.Keccak256Hash([]byte(rule))
-				copy(topic[:], hash[:])
-			case []byte:
-				hash := crypto.Keccak256Hash(rule)
-				copy(topic[:], hash[:])
-
-			default:
-				// todo(rjl493456442) according solidity documentation, indexed event
-				// parameters that are not value types i.e. arrays and structs are not
-				// stored directly but instead a keccak256-hash of an encoding is stored.
-				//
-				// We only convert stringS and bytes to hash, still need to deal with
-				// array(both fixed-size and dynamic-size) and struct.
-
-				// Attempt to generate the topic from funky types
-				val := reflect.ValueOf(rule)
-				switch {
-				// static byte array
-				case val.Kind() == reflect.Array && reflect.TypeOf(rule).Elem().Kind() == reflect.Uint8:
-					reflect.Copy(reflect.ValueOf(topic[:val.Len()]), val)
-				default:
-					return nil, fmt.Errorf("unsupported indexed type: %T", rule)
-				}
-			}
-			topics[i] = append(topics[i], topic)
-		}
-	}
-	return topics, nil
-}
-
-func genIntType(rule int64, size uint) []byte {
-	var topic [common.HashLength]byte
-	if rule < 0 {
-		// if a rule is negative, we need to put it into two's complement.
-		// extended to common.HashLength bytes.
-		topic = [common.HashLength]byte{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
-	}
-	for i := uint(0); i < size; i++ {
-		topic[common.HashLength-i-1] = byte(rule >> (i * 8))
-	}
-	return topic[:]
-}
-
-// ParseTopics converts the indexed topic fields into actual log field values.
-func ParseTopics(out interface{}, fields Arguments, topics []common.Hash) error {
-	return parseTopicWithSetter(fields, topics,
-		func(arg Argument, reconstr interface{}) {
-			field := reflect.ValueOf(out).Elem().FieldByName(ToCamelCase(arg.Name))
-			field.Set(reflect.ValueOf(reconstr))
-		})
-}
-
-// ParseTopicsIntoMap converts the indexed topic field-value pairs into map key-value pairs.
-func ParseTopicsIntoMap(out map[string]interface{}, fields Arguments, topics []common.Hash) error {
-	return parseTopicWithSetter(fields, topics,
-		func(arg Argument, reconstr interface{}) {
-			out[arg.Name] = reconstr
-		})
-}
-
-// parseTopicWithSetter converts the indexed topic field-value pairs and stores them using the
-// provided set function.
-//
-// Note, dynamic types cannot be reconstructed since they get mapped to Keccak256
-// hashes as the topic value!
-func parseTopicWithSetter(fields Arguments, topics []common.Hash, setter func(Argument, interface{})) error {
-	// Sanity check that the fields and topics match up
-	if len(fields) != len(topics) {
-		return errors.New("topic/field count mismatch")
-	}
-	// Iterate over all the fields and reconstruct them from topics
-	for i, arg := range fields {
-		if !arg.Indexed {
-			return errors.New("non-indexed field in topic reconstruction")
-		}
-		var reconstr interface{}
-		switch arg.Type.T {
-		case TupleTy:
-			return errors.New("tuple type in topic reconstruction")
-		case StringTy, BytesTy, SliceTy, ArrayTy:
-			// Array types (including strings and bytes) have their keccak256 hashes stored in the topic- not a hash
-			// whose bytes can be decoded to the actual value- so the best we can do is retrieve that hash
-			reconstr = topics[i]
-		case FunctionTy:
-			if garbage := binary.BigEndian.Uint64(topics[i][0:8]); garbage != 0 {
-				return fmt.Errorf("bind: got improperly encoded function type, got %v", topics[i].Bytes())
-			}
-			var tmp [24]byte
-			copy(tmp[:], topics[i][8:32])
-			reconstr = tmp
-		default:
-			var err error
-			reconstr, err = toGoType(0, arg.Type, topics[i].Bytes())
-			if err != nil {
-				return err
-			}
-		}
-		// Use the setter function to store the value
-		setter(arg, reconstr)
-	}
-
-	return nil
-}

accounts/abi/topics_test.go

@@ -1,381 +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 (
-	"math/big"
-	"reflect"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-)
-
-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,
-		},
-		{
-			"support common hash types in topics",
-			args{[][]interface{}{{common.Hash{1, 2, 3, 4, 5}}}},
-			[][]common.Hash{{common.Hash{1, 2, 3, 4, 5}}},
-			false,
-		},
-		{
-			"support address types in topics",
-			args{[][]interface{}{{common.Address{1, 2, 3, 4, 5}}}},
-			[][]common.Hash{{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5}}},
-			false,
-		},
-		{
-			"support *big.Int types in topics",
-			args{[][]interface{}{{big.NewInt(1).Lsh(big.NewInt(2), 254)}}},
-			[][]common.Hash{{common.Hash{128}}},
-			false,
-		},
-		{
-			"support boolean types in topics",
-			args{[][]interface{}{
-				{true},
-				{false},
-			}},
-			[][]common.Hash{
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
-				{common.Hash{0}},
-			},
-			false,
-		},
-		{
-			"support int/uint(8/16/32/64) types in topics",
-			args{[][]interface{}{
-				{int8(-2)},
-				{int16(-3)},
-				{int32(-4)},
-				{int64(-5)},
-				{int8(1)},
-				{int16(256)},
-				{int32(65536)},
-				{int64(4294967296)},
-				{uint8(1)},
-				{uint16(256)},
-				{uint32(65536)},
-				{uint64(4294967296)},
-			}},
-			[][]common.Hash{
-				{common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 254}},
-				{common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 253}},
-				{common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 252}},
-				{common.Hash{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 251}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0}},
-				{common.Hash{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0}},
-			},
-			false,
-		},
-		{
-			"support string types in topics",
-			args{[][]interface{}{{"hello world"}}},
-			[][]common.Hash{{crypto.Keccak256Hash([]byte("hello world"))}},
-			false,
-		},
-		{
-			"support byte slice types in topics",
-			args{[][]interface{}{{[]byte{1, 2, 3}}}},
-			[][]common.Hash{{crypto.Keccak256Hash([]byte{1, 2, 3})}},
-			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)
-			}
-		})
-	}
-}
-
-type args struct {
-	createObj func() interface{}
-	resultObj func() interface{}
-	resultMap func() map[string]interface{}
-	fields    Arguments
-	topics    []common.Hash
-}
-
-type bytesStruct struct {
-	StaticBytes [5]byte
-}
-type int8Struct struct {
-	Int8Value int8
-}
-type int256Struct struct {
-	Int256Value *big.Int
-}
-
-type hashStruct struct {
-	HashValue common.Hash
-}
-
-type funcStruct struct {
-	FuncValue [24]byte
-}
-
-type topicTest struct {
-	name    string
-	args    args
-	wantErr bool
-}
-
-func setupTopicsTests() []topicTest {
-	bytesType, _ := NewType("bytes5", "", nil)
-	int8Type, _ := NewType("int8", "", nil)
-	int256Type, _ := NewType("int256", "", nil)
-	tupleType, _ := NewType("tuple(int256,int8)", "", nil)
-	stringType, _ := NewType("string", "", nil)
-	funcType, _ := NewType("function", "", nil)
-
-	tests := []topicTest{
-		{
-			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}} },
-				resultMap: func() map[string]interface{} {
-					return map[string]interface{}{"staticBytes": [5]byte{1, 2, 3, 4, 5}}
-				},
-				fields: Arguments{Argument{
-					Name:    "staticBytes",
-					Type:    bytesType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{1, 2, 3, 4, 5},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "int8 with negative value",
-			args: args{
-				createObj: func() interface{} { return &int8Struct{} },
-				resultObj: func() interface{} { return &int8Struct{Int8Value: -1} },
-				resultMap: func() map[string]interface{} {
-					return map[string]interface{}{"int8Value": int8(-1)}
-				},
-				fields: Arguments{Argument{
-					Name:    "int8Value",
-					Type:    int8Type,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "int256 with negative value",
-			args: args{
-				createObj: func() interface{} { return &int256Struct{} },
-				resultObj: func() interface{} { return &int256Struct{Int256Value: big.NewInt(-1)} },
-				resultMap: func() map[string]interface{} {
-					return map[string]interface{}{"int256Value": big.NewInt(-1)}
-				},
-				fields: Arguments{Argument{
-					Name:    "int256Value",
-					Type:    int256Type,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "hash type",
-			args: args{
-				createObj: func() interface{} { return &hashStruct{} },
-				resultObj: func() interface{} { return &hashStruct{crypto.Keccak256Hash([]byte("stringtopic"))} },
-				resultMap: func() map[string]interface{} {
-					return map[string]interface{}{"hashValue": crypto.Keccak256Hash([]byte("stringtopic"))}
-				},
-				fields: Arguments{Argument{
-					Name:    "hashValue",
-					Type:    stringType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					crypto.Keccak256Hash([]byte("stringtopic")),
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "function type",
-			args: args{
-				createObj: func() interface{} { return &funcStruct{} },
-				resultObj: func() interface{} {
-					return &funcStruct{[24]byte{255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}
-				},
-				resultMap: func() map[string]interface{} {
-					return map[string]interface{}{"funcValue": [24]byte{255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}}
-				},
-				fields: Arguments{Argument{
-					Name:    "funcValue",
-					Type:    funcType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "error on topic/field count mismatch",
-			args: args{
-				createObj: func() interface{} { return nil },
-				resultObj: func() interface{} { return nil },
-				resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
-				fields: Arguments{Argument{
-					Name:    "tupletype",
-					Type:    tupleType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{},
-			},
-			wantErr: true,
-		},
-		{
-			name: "error on unindexed arguments",
-			args: args{
-				createObj: func() interface{} { return &int256Struct{} },
-				resultObj: func() interface{} { return &int256Struct{} },
-				resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
-				fields: Arguments{Argument{
-					Name:    "int256Value",
-					Type:    int256Type,
-					Indexed: false,
-				}},
-				topics: []common.Hash{
-					{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
-				},
-			},
-			wantErr: true,
-		},
-		{
-			name: "error on tuple in topic reconstruction",
-			args: args{
-				createObj: func() interface{} { return &tupleType },
-				resultObj: func() interface{} { return &tupleType },
-				resultMap: func() map[string]interface{} { return make(map[string]interface{}) },
-				fields: Arguments{Argument{
-					Name:    "tupletype",
-					Type:    tupleType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{{0}},
-			},
-			wantErr: true,
-		},
-		{
-			name: "error on improper encoded function",
-			args: args{
-				createObj: func() interface{} { return &funcStruct{} },
-				resultObj: func() interface{} { return &funcStruct{} },
-				resultMap: func() map[string]interface{} {
-					return make(map[string]interface{})
-				},
-				fields: Arguments{Argument{
-					Name:    "funcValue",
-					Type:    funcType,
-					Indexed: true,
-				}},
-				topics: []common.Hash{
-					{0, 0, 0, 0, 0, 0, 0, 128, 255, 255, 255, 255, 255, 255, 255, 255,
-						255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
-				},
-			},
-			wantErr: true,
-		},
-	}
-
-	return tests
-}
-
-func TestParseTopics(t *testing.T) {
-	tests := setupTopicsTests()
-
-	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)
-			}
-		})
-	}
-}
-
-func TestParseTopicsIntoMap(t *testing.T) {
-	tests := setupTopicsTests()
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			outMap := make(map[string]interface{})
-			if err := ParseTopicsIntoMap(outMap, tt.args.fields, tt.args.topics); (err != nil) != tt.wantErr {
-				t.Errorf("parseTopicsIntoMap() error = %v, wantErr %v", err, tt.wantErr)
-			}
-			resultMap := tt.args.resultMap()
-			if !reflect.DeepEqual(outMap, resultMap) {
-				t.Errorf("parseTopicsIntoMap() = %v, want %v", outMap, resultMap)
-			}
-		})
-	}
-}

accounts/abi/type.go

@@ -23,8 +23,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-
-	"github.com/ethereum/go-ethereum/common"
 )
 
 // Type enumerator
@@ -44,19 +42,19 @@ const (
 	FunctionTy
 )
 
-// Type is the reflection of the supported argument type.
+// 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
-	TupleRawName  string       // Raw struct name defined in source code, may be empty.
 	TupleElems    []*Type  // Type information of all tuple fields
 	TupleRawNames []string // Raw field name of all tuple fields
-	TupleType     reflect.Type // Underlying struct of the tuple
 }
 
 var (
@@ -65,24 +63,20 @@ var (
 )
 
 // NewType creates a new reflection type of abi type given in t.
-func NewType(t string, internalType string, components []ArgumentMarshaling) (typ Type, err error) {
+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 {
-		// Note internalType can be empty here.
-		subInternal := internalType
-		if i := strings.LastIndex(internalType, "["); i != -1 {
-			subInternal = subInternal[:i]
-		}
-		// recursively embed the type
 		i := strings.LastIndex(t, "[")
-		embeddedType, err := NewType(t[:i], subInternal, components)
+		// recursively embed the type
+		embeddedType, err := NewType(t[:i], components)
 		if err != nil {
 			return Type{}, err
 		}
@@ -95,17 +89,25 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 		if len(intz) == 0 {
 			// is a slice
 			typ.T = SliceTy
+			typ.Kind = reflect.Slice
 			typ.Elem = &embeddedType
+			typ.Type = reflect.SliceOf(embeddedType.Type)
+			if embeddedType.T == TupleTy {
 				typ.stringKind = embeddedType.stringKind + sliced
+			}
 		} else if len(intz) == 1 {
-			// is an array
+			// 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)
+			if embeddedType.T == TupleTy {
 				typ.stringKind = embeddedType.stringKind + sliced
+			}
 		} else {
 			return Type{}, fmt.Errorf("invalid formatting of array type")
 		}
@@ -136,24 +138,36 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 	// 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 (
@@ -163,21 +177,17 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 			expression string // canonical parameter expression
 		)
 		expression += "("
-		overloadedNames := make(map[string]string)
 		for idx, c := range components {
-			cType, err := NewType(c.Type, c.InternalType, c.Components)
+			cType, err := NewType(c.Type, c.Components)
 			if err != nil {
 				return Type{}, err
 			}
-			fieldName, err := overloadedArgName(c.Name, overloadedNames)
-			if err != nil {
-				return Type{}, err
+			if ToCamelCase(c.Name) == "" {
+				return Type{}, errors.New("abi: purely anonymous or underscored field is not supported")
 			}
-			overloadedNames[fieldName] = fieldName
 			fields = append(fields, reflect.StructField{
-				Name: fieldName, // reflect.StructOf will panic for any exported field.
-				Type: cType.GetType(),
-				Tag:  reflect.StructTag("json:\"" + c.Name + "\""),
+				Name: ToCamelCase(c.Name), // reflect.StructOf will panic for any exported field.
+				Type: cType.Type,
 			})
 			elems = append(elems, &cType)
 			names = append(names, c.Name)
@@ -187,26 +197,17 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 			}
 		}
 		expression += ")"
-
-		typ.TupleType = reflect.StructOf(fields)
+		typ.Kind = reflect.Struct
+		typ.Type = reflect.StructOf(fields)
 		typ.TupleElems = elems
 		typ.TupleRawNames = names
 		typ.T = TupleTy
 		typ.stringKind = expression
-
-		const structPrefix = "struct "
-		// After solidity 0.5.10, a new field of abi "internalType"
-		// is introduced. From that we can obtain the struct name
-		// user defined in the source code.
-		if internalType != "" && strings.HasPrefix(internalType, structPrefix) {
-			// Foo.Bar type definition is not allowed in golang,
-			// convert the format to FooBar
-			typ.TupleRawName = strings.Replace(internalType[len(structPrefix):], ".", "", -1)
-		}
-
 	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)
 	}
@@ -214,57 +215,7 @@ func NewType(t string, internalType string, components []ArgumentMarshaling) (ty
 	return
 }
 
-// GetType returns the reflection type of the ABI type.
-func (t Type) GetType() reflect.Type {
-	switch t.T {
-	case IntTy:
-		return reflectIntType(false, t.Size)
-	case UintTy:
-		return reflectIntType(true, t.Size)
-	case BoolTy:
-		return reflect.TypeOf(false)
-	case StringTy:
-		return reflect.TypeOf("")
-	case SliceTy:
-		return reflect.SliceOf(t.Elem.GetType())
-	case ArrayTy:
-		return reflect.ArrayOf(t.Size, t.Elem.GetType())
-	case TupleTy:
-		return t.TupleType
-	case AddressTy:
-		return reflect.TypeOf(common.Address{})
-	case FixedBytesTy:
-		return reflect.ArrayOf(t.Size, reflect.TypeOf(byte(0)))
-	case BytesTy:
-		return reflect.SliceOf(reflect.TypeOf(byte(0)))
-	case HashTy:
-		// hashtype currently not used
-		return reflect.ArrayOf(32, reflect.TypeOf(byte(0)))
-	case FixedPointTy:
-		// fixedpoint type currently not used
-		return reflect.ArrayOf(32, reflect.TypeOf(byte(0)))
-	case FunctionTy:
-		return reflect.ArrayOf(24, reflect.TypeOf(byte(0)))
-	default:
-		panic("Invalid type")
-	}
-}
-
-func overloadedArgName(rawName string, names map[string]string) (string, error) {
-	fieldName := ToCamelCase(rawName)
-	if fieldName == "" {
-		return "", errors.New("abi: purely anonymous or underscored field is not supported")
-	}
-	// Handle overloaded fieldNames
-	_, ok := names[fieldName]
-	for idx := 0; ok; idx++ {
-		fieldName = fmt.Sprintf("%s%d", ToCamelCase(rawName), idx)
-		_, ok = names[fieldName]
-	}
-	return fieldName, nil
-}
-
-// String implements Stringer.
+// String implements Stringer
 func (t Type) String() (out string) {
 	return t.stringKind
 }
@@ -346,7 +297,7 @@ func (t Type) pack(v reflect.Value) ([]byte, error) {
 		return append(ret, tail...), nil
 
 	default:
-		return packElement(t, v)
+		return packElement(t, v), nil
 	}
 }
 
@@ -386,7 +337,7 @@ func isDynamicType(t Type) bool {
 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 || t.Elem.T == TupleTy {
+		if t.Elem.T == ArrayTy {
 			return t.Size * getTypeSize(*t.Elem)
 		}
 		return t.Size * 32

accounts/abi/type_test.go

@@ -36,58 +36,58 @@ func TestTypeRegexp(t *testing.T) {
 		components []ArgumentMarshaling
 		kind       Type
 	}{
-		{"bool", nil, Type{T: BoolTy, stringKind: "bool"}},
-		{"bool[]", nil, Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}},
-		{"bool[2]", nil, Type{Size: 2, T: ArrayTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}},
-		{"bool[2][]", nil, Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}},
-		{"bool[][]", nil, Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}},
-		{"bool[][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}},
-		{"bool[2][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}},
-		{"bool[2][][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][]"}, stringKind: "bool[2][][2]"}},
-		{"bool[2][2][2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[2]"}, stringKind: "bool[2][2]"}, stringKind: "bool[2][2][2]"}},
-		{"bool[][][]", nil, Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][]"}, stringKind: "bool[][][]"}},
-		{"bool[][2][]", nil, Type{T: SliceTy, Elem: &Type{T: ArrayTy, Size: 2, Elem: &Type{T: SliceTy, Elem: &Type{T: BoolTy, stringKind: "bool"}, stringKind: "bool[]"}, stringKind: "bool[][2]"}, stringKind: "bool[][2][]"}},
-		{"int8", nil, Type{Size: 8, T: IntTy, stringKind: "int8"}},
-		{"int16", nil, Type{Size: 16, T: IntTy, stringKind: "int16"}},
-		{"int32", nil, Type{Size: 32, T: IntTy, stringKind: "int32"}},
-		{"int64", nil, Type{Size: 64, T: IntTy, stringKind: "int64"}},
-		{"int256", nil, Type{Size: 256, T: IntTy, stringKind: "int256"}},
-		{"int8[]", nil, Type{T: SliceTy, Elem: &Type{Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[]"}},
-		{"int8[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 8, T: IntTy, stringKind: "int8"}, stringKind: "int8[2]"}},
-		{"int16[]", nil, Type{T: SliceTy, Elem: &Type{Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[]"}},
-		{"int16[2]", nil, Type{Size: 2, T: ArrayTy, Elem: &Type{Size: 16, T: IntTy, stringKind: "int16"}, stringKind: "int16[2]"}},
-		{"int32[]", nil, Type{T: SliceTy, Elem: &Type{Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[]"}},
-		{"int32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 32, T: IntTy, stringKind: "int32"}, stringKind: "int32[2]"}},
-		{"int64[]", nil, Type{T: SliceTy, Elem: &Type{Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[]"}},
-		{"int64[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 64, T: IntTy, stringKind: "int64"}, stringKind: "int64[2]"}},
-		{"int256[]", nil, Type{T: SliceTy, Elem: &Type{Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[]"}},
-		{"int256[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 256, T: IntTy, stringKind: "int256"}, stringKind: "int256[2]"}},
-		{"uint8", nil, Type{Size: 8, T: UintTy, stringKind: "uint8"}},
-		{"uint16", nil, Type{Size: 16, T: UintTy, stringKind: "uint16"}},
-		{"uint32", nil, Type{Size: 32, T: UintTy, stringKind: "uint32"}},
-		{"uint64", nil, Type{Size: 64, T: UintTy, stringKind: "uint64"}},
-		{"uint256", nil, Type{Size: 256, T: UintTy, stringKind: "uint256"}},
-		{"uint8[]", nil, Type{T: SliceTy, Elem: &Type{Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[]"}},
-		{"uint8[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 8, T: UintTy, stringKind: "uint8"}, stringKind: "uint8[2]"}},
-		{"uint16[]", nil, Type{T: SliceTy, Elem: &Type{Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[]"}},
-		{"uint16[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 16, T: UintTy, stringKind: "uint16"}, stringKind: "uint16[2]"}},
-		{"uint32[]", nil, Type{T: SliceTy, Elem: &Type{Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[]"}},
-		{"uint32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 32, T: UintTy, stringKind: "uint32"}, stringKind: "uint32[2]"}},
-		{"uint64[]", nil, Type{T: SliceTy, Elem: &Type{Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[]"}},
-		{"uint64[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 64, T: UintTy, stringKind: "uint64"}, stringKind: "uint64[2]"}},
-		{"uint256[]", nil, Type{T: SliceTy, Elem: &Type{Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[]"}},
-		{"uint256[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 256, T: UintTy, stringKind: "uint256"}, stringKind: "uint256[2]"}},
-		{"bytes32", nil, Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}},
-		{"bytes[]", nil, Type{T: SliceTy, Elem: &Type{T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[]"}},
-		{"bytes[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: BytesTy, stringKind: "bytes"}, stringKind: "bytes[2]"}},
-		{"bytes32[]", nil, Type{T: SliceTy, Elem: &Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[]"}},
-		{"bytes32[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: FixedBytesTy, Size: 32, stringKind: "bytes32"}, stringKind: "bytes32[2]"}},
-		{"string", nil, Type{T: StringTy, stringKind: "string"}},
-		{"string[]", nil, Type{T: SliceTy, Elem: &Type{T: StringTy, stringKind: "string"}, stringKind: "string[]"}},
-		{"string[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{T: StringTy, stringKind: "string"}, stringKind: "string[2]"}},
-		{"address", nil, Type{Size: 20, T: AddressTy, stringKind: "address"}},
-		{"address[]", nil, Type{T: SliceTy, Elem: &Type{Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[]"}},
-		{"address[2]", nil, Type{T: ArrayTy, Size: 2, Elem: &Type{Size: 20, T: AddressTy, stringKind: "address"}, stringKind: "address[2]"}},
+		{"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{}},
@@ -95,18 +95,12 @@ func TestTypeRegexp(t *testing.T) {
 		// {"fixed[2]", nil, Type{}},
 		// {"fixed128x128[]", nil, Type{}},
 		// {"fixed128x128[2]", nil, Type{}},
-		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "int64"}}, Type{T: TupleTy, TupleType: reflect.TypeOf(struct {
-			A int64 `json:"a"`
-		}{}), stringKind: "(int64)",
-			TupleElems: []*Type{{T: IntTy, Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"a"}}},
-		{"tuple with long name", []ArgumentMarshaling{{Name: "aTypicalParamName", Type: "int64"}}, Type{T: TupleTy, TupleType: reflect.TypeOf(struct {
-			ATypicalParamName int64 `json:"aTypicalParamName"`
-		}{}), stringKind: "(int64)",
-			TupleElems: []*Type{{T: IntTy, Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"aTypicalParamName"}}},
+		{"tuple", []ArgumentMarshaling{{Name: "a", Type: "int64"}}, Type{Kind: reflect.Struct, T: TupleTy, Type: reflect.TypeOf(struct{ A int64 }{}), stringKind: "(int64)",
+			TupleElems: []*Type{{Kind: reflect.Int64, T: IntTy, Type: reflect.TypeOf(int64(0)), Size: 64, stringKind: "int64"}}, TupleRawNames: []string{"a"}}},
 	}
 
 	for _, tt := range tests {
-		typ, err := NewType(tt.blob, "", tt.components)
+		typ, err := NewType(tt.blob, tt.components)
 		if err != nil {
 			t.Errorf("type %q: failed to parse type string: %v", tt.blob, err)
 		}
@@ -255,7 +249,7 @@ func TestTypeCheck(t *testing.T) {
 		{"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", nil, string(""), ""},
 		{"string", nil, []byte{}, "abi: cannot use slice as type string as argument"},
 		{"bytes32[]", nil, [][32]byte{{}}, ""},
 		{"function", nil, [24]byte{}, ""},
@@ -281,7 +275,7 @@ func TestTypeCheck(t *testing.T) {
 			B *big.Int
 		}{{big.NewInt(0), big.NewInt(0)}, {big.NewInt(0), big.NewInt(0)}}, ""},
 	} {
-		typ, err := NewType(test.typ, "", test.components)
+		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 {
@@ -306,63 +300,3 @@ func TestTypeCheck(t *testing.T) {
 		}
 	}
 }
-
-func TestInternalType(t *testing.T) {
-	components := []ArgumentMarshaling{{Name: "a", Type: "int64"}}
-	internalType := "struct a.b[]"
-	kind := Type{
-		T: TupleTy,
-		TupleType: reflect.TypeOf(struct {
-			A int64 `json:"a"`
-		}{}),
-		stringKind:    "(int64)",
-		TupleRawName:  "ab[]",
-		TupleElems:    []*Type{{T: IntTy, Size: 64, stringKind: "int64"}},
-		TupleRawNames: []string{"a"},
-	}
-
-	blob := "tuple"
-	typ, err := NewType(blob, internalType, components)
-	if err != nil {
-		t.Errorf("type %q: failed to parse type string: %v", blob, err)
-	}
-	if !reflect.DeepEqual(typ, kind) {
-		t.Errorf("type %q: parsed type mismatch:\nGOT %s\nWANT %s ", blob, spew.Sdump(typeWithoutStringer(typ)), spew.Sdump(typeWithoutStringer(kind)))
-	}
-}
-
-func TestGetTypeSize(t *testing.T) {
-	var testCases = []struct {
-		typ        string
-		components []ArgumentMarshaling
-		typSize    int
-	}{
-		// simple array
-		{"uint256[2]", nil, 32 * 2},
-		{"address[3]", nil, 32 * 3},
-		{"bytes32[4]", nil, 32 * 4},
-		// array array
-		{"uint256[2][3][4]", nil, 32 * (2 * 3 * 4)},
-		// array tuple
-		{"tuple[2]", []ArgumentMarshaling{{Name: "x", Type: "bytes32"}, {Name: "y", Type: "bytes32"}}, (32 * 2) * 2},
-		// simple tuple
-		{"tuple", []ArgumentMarshaling{{Name: "x", Type: "uint256"}, {Name: "y", Type: "uint256"}}, 32 * 2},
-		// tuple array
-		{"tuple", []ArgumentMarshaling{{Name: "x", Type: "bytes32[2]"}}, 32 * 2},
-		// tuple tuple
-		{"tuple", []ArgumentMarshaling{{Name: "x", Type: "tuple", Components: []ArgumentMarshaling{{Name: "x", Type: "bytes32"}}}}, 32},
-		{"tuple", []ArgumentMarshaling{{Name: "x", Type: "tuple", Components: []ArgumentMarshaling{{Name: "x", Type: "bytes32[2]"}, {Name: "y", Type: "uint256"}}}}, 32 * (2 + 1)},
-	}
-
-	for i, data := range testCases {
-		typ, err := NewType(data.typ, "", data.components)
-		if err != nil {
-			t.Errorf("type %q: failed to parse type string: %v", data.typ, err)
-		}
-
-		result := getTypeSize(typ)
-		if result != data.typSize {
-			t.Errorf("case %d type %q: get type size error: actual: %d expected: %d", i, data.typ, result, data.typSize)
-		}
-	}
-}

accounts/abi/unpack.go

@@ -26,54 +26,52 @@ import (
 )
 
 var (
-	// MaxUint256 is the maximum value that can be represented by a uint256.
-	MaxUint256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 256), common.Big1)
-	// MaxInt256 is the maximum value that can be represented by a int256.
-	MaxInt256 = new(big.Int).Sub(new(big.Int).Lsh(common.Big1, 255), common.Big1)
+	maxUint256 = big.NewInt(0).Add(
+		big.NewInt(0).Exp(big.NewInt(2), big.NewInt(256), nil),
+		big.NewInt(-1))
+	maxInt256 = big.NewInt(0).Add(
+		big.NewInt(0).Exp(big.NewInt(2), big.NewInt(255), nil),
+		big.NewInt(-1))
 )
 
-// ReadInteger reads the integer based on its kind and returns the appropriate value.
-func ReadInteger(typ Type, b []byte) interface{} {
-	if typ.T == UintTy {
-		switch typ.Size {
-		case 8:
+// reads the integer based on its kind
+func readInteger(typ byte, kind reflect.Kind, b []byte) interface{} {
+	switch kind {
+	case reflect.Uint8:
 		return b[len(b)-1]
-		case 16:
+	case reflect.Uint16:
 		return binary.BigEndian.Uint16(b[len(b)-2:])
-		case 32:
+	case reflect.Uint32:
 		return binary.BigEndian.Uint32(b[len(b)-4:])
-		case 64:
+	case reflect.Uint64:
 		return binary.BigEndian.Uint64(b[len(b)-8:])
-		default:
-			// the only case left for unsigned integer is uint256.
-			return new(big.Int).SetBytes(b)
-		}
-	}
-	switch typ.Size {
-	case 8:
+	case reflect.Int8:
 		return int8(b[len(b)-1])
-	case 16:
+	case reflect.Int16:
 		return int16(binary.BigEndian.Uint16(b[len(b)-2:]))
-	case 32:
+	case reflect.Int32:
 		return int32(binary.BigEndian.Uint32(b[len(b)-4:]))
-	case 64:
+	case reflect.Int64:
 		return int64(binary.BigEndian.Uint64(b[len(b)-8:]))
 	default:
-		// the only case left for integer is int256
-		// big.SetBytes can't tell if a number is negative or positive in itself.
+		// the only case lefts for integer is int256/uint256.
+		// big.SetBytes can't tell if a number is negative, positive on itself.
 		// On EVM, if the returned number > max int256, it is negative.
-		// A number is > max int256 if the bit at position 255 is set.
 		ret := new(big.Int).SetBytes(b)
-		if ret.Bit(255) == 1 {
-			ret.Add(MaxUint256, new(big.Int).Neg(ret))
-			ret.Add(ret, common.Big1)
+		if typ == UintTy {
+			return ret
+		}
+
+		if ret.Cmp(maxInt256) > 0 {
+			ret.Add(maxUint256, big.NewInt(0).Neg(ret))
+			ret.Add(ret, big.NewInt(1))
 			ret.Neg(ret)
 		}
 		return ret
 	}
 }
 
-// readBool reads a bool.
+// reads a bool
 func readBool(word []byte) (bool, error) {
 	for _, b := range word[:31] {
 		if b != 0 {
@@ -91,8 +89,7 @@ func readBool(word []byte) (bool, error) {
 }
 
 // A function type is simply the address with the function selection signature at the end.
-//
-// readFunctionType enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
+// This enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes)
 func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 	if t.T != FunctionTy {
 		return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array")
@@ -105,20 +102,20 @@ func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) {
 	return
 }
 
-// ReadFixedBytes uses reflection to create a fixed array to be read from.
-func ReadFixedBytes(t Type, word []byte) (interface{}, error) {
+// through reflection, creates a fixed array to be read from
+func readFixedBytes(t Type, word []byte) (interface{}, error) {
 	if t.T != FixedBytesTy {
 		return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array")
 	}
 	// convert
-	array := reflect.New(t.GetType()).Elem()
+	array := reflect.New(t.Type).Elem()
 
 	reflect.Copy(array, reflect.ValueOf(word[0:t.Size]))
 	return array.Interface(), nil
 
 }
 
-// forEachUnpack iteratively unpack elements.
+// iteratively unpack elements
 func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error) {
 	if size < 0 {
 		return nil, fmt.Errorf("cannot marshal input to array, size is negative (%d)", size)
@@ -132,10 +129,10 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error)
 
 	if t.T == SliceTy {
 		// declare our slice
-		refSlice = reflect.MakeSlice(t.GetType(), size, size)
+		refSlice = reflect.MakeSlice(t.Type, size, size)
 	} else if t.T == ArrayTy {
 		// declare our array
-		refSlice = reflect.New(t.GetType()).Elem()
+		refSlice = reflect.New(t.Type).Elem()
 	} else {
 		return nil, fmt.Errorf("abi: invalid type in array/slice unpacking stage")
 	}
@@ -159,7 +156,7 @@ func forEachUnpack(t Type, output []byte, start, size int) (interface{}, error)
 }
 
 func forTupleUnpack(t Type, output []byte) (interface{}, error) {
-	retval := reflect.New(t.GetType()).Elem()
+	retval := reflect.New(t.Type).Elem()
 	virtualArgs := 0
 	for index, elem := range t.TupleElems {
 		marshalledValue, err := toGoType((index+virtualArgs)*32, *elem, output)
@@ -219,23 +216,21 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 				return nil, err
 			}
 			return forTupleUnpack(t, output[begin:])
-		}
+		} else {
 			return forTupleUnpack(t, output[index:])
+		}
 	case SliceTy:
 		return forEachUnpack(t, output[begin:], 0, length)
 	case ArrayTy:
 		if isDynamicType(*t.Elem) {
-			offset := binary.BigEndian.Uint64(returnOutput[len(returnOutput)-8:])
-			if offset > uint64(len(output)) {
-				return nil, fmt.Errorf("abi: toGoType offset greater than output length: offset: %d, len(output): %d", offset, len(output))
-			}
+			offset := int64(binary.BigEndian.Uint64(returnOutput[len(returnOutput)-8:]))
 			return forEachUnpack(t, output[offset:], 0, t.Size)
 		}
 		return forEachUnpack(t, output[index:], 0, t.Size)
 	case StringTy: // variable arrays are written at the end of the return bytes
 		return string(output[begin : begin+length]), nil
 	case IntTy, UintTy:
-		return ReadInteger(t, returnOutput), nil
+		return readInteger(t.T, t.Kind, returnOutput), nil
 	case BoolTy:
 		return readBool(returnOutput)
 	case AddressTy:
@@ -245,7 +240,7 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 	case BytesTy:
 		return output[begin : begin+length], nil
 	case FixedBytesTy:
-		return ReadFixedBytes(t, returnOutput)
+		return readFixedBytes(t, returnOutput)
 	case FunctionTy:
 		return readFunctionType(t, returnOutput)
 	default:
@@ -253,7 +248,7 @@ func toGoType(index int, t Type, output []byte) (interface{}, error) {
 	}
 }
 
-// lengthPrefixPointsTo interprets a 32 byte slice as an offset and then determines which indices to look to decode the type.
+// interprets a 32 byte slice as an offset and then determines which indice to look to decode the type.
 func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err error) {
 	bigOffsetEnd := big.NewInt(0).SetBytes(output[index : index+32])
 	bigOffsetEnd.Add(bigOffsetEnd, common.Big32)
@@ -274,7 +269,7 @@ func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err
 	totalSize.Add(totalSize, bigOffsetEnd)
 	totalSize.Add(totalSize, lengthBig)
 	if totalSize.BitLen() > 63 {
-		return 0, 0, fmt.Errorf("abi: length larger than int64: %v", totalSize)
+		return 0, 0, fmt.Errorf("abi length larger than int64: %v", totalSize)
 	}
 
 	if totalSize.Cmp(outputLength) > 0 {

accounts/abi/unpack_test.go

@@ -30,32 +30,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// TestUnpack tests the general pack/unpack tests in packing_test.go
-func TestUnpack(t *testing.T) {
-	for i, test := range packUnpackTests {
-		t.Run(strconv.Itoa(i)+" "+test.def, func(t *testing.T) {
-			//Unpack
-			def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
-			abi, err := JSON(strings.NewReader(def))
-			if err != nil {
-				t.Fatalf("invalid ABI definition %s: %v", def, err)
-			}
-			encb, err := hex.DecodeString(test.packed)
-			if err != nil {
-				t.Fatalf("invalid hex %s: %v", test.packed, err)
-			}
-			out, err := abi.Unpack("method", encb)
-			if err != nil {
-				t.Errorf("test %d (%v) failed: %v", i, test.def, err)
-				return
-			}
-			if !reflect.DeepEqual(test.unpacked, ConvertType(out[0], test.unpacked)) {
-				t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.unpacked, out[0])
-			}
-		})
-	}
-}
-
 type unpackTest struct {
 	def  string      // ABI definition JSON
 	enc  string      // evm return data
@@ -77,7 +51,16 @@ func (test unpackTest) checkError(err error) error {
 }
 
 var unpackTests = []unpackTest{
-	// Bools
+	{
+		def:  `[{ "type": "bool" }]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
+		want: true,
+	},
+	{
+		def:  `[{ "type": "bool" }]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000000",
+		want: false,
+	},
 	{
 		def:  `[{ "type": "bool" }]`,
 		enc:  "0000000000000000000000000000000000000000000000000001000000000001",
@@ -90,7 +73,11 @@ var unpackTests = []unpackTest{
 		want: false,
 		err:  "abi: improperly encoded boolean value",
 	},
-	// Integers
+	{
+		def:  `[{"type": "uint32"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
+		want: uint32(1),
+	},
 	{
 		def:  `[{"type": "uint32"}]`,
 		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
@@ -103,6 +90,16 @@ var unpackTests = []unpackTest{
 		want: uint16(0),
 		err:  "abi: cannot unmarshal *big.Int in to uint16",
 	},
+	{
+		def:  `[{"type": "uint17"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
+		want: big.NewInt(1),
+	},
+	{
+		def:  `[{"type": "int32"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
+		want: int32(1),
+	},
 	{
 		def:  `[{"type": "int32"}]`,
 		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
@@ -115,10 +112,36 @@ var unpackTests = []unpackTest{
 		want: int16(0),
 		err:  "abi: cannot unmarshal *big.Int in to int16",
 	},
+	{
+		def:  `[{"type": "int17"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001",
+		want: big.NewInt(1),
+	},
+	{
+		def:  `[{"type": "int256"}]`,
+		enc:  "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+		want: big.NewInt(-1),
+	},
+	{
+		def:  `[{"type": "address"}]`,
+		enc:  "0000000000000000000000000100000000000000000000000000000000000000",
+		want: common.Address{1},
+	},
+	{
+		def:  `[{"type": "bytes32"}]`,
+		enc:  "0100000000000000000000000000000000000000000000000000000000000000",
+		want: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	},
 	{
 		def:  `[{"type": "bytes"}]`,
 		enc:  "000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000",
-		want: [32]byte{1},
+		want: common.Hex2Bytes("0100000000000000000000000000000000000000000000000000000000000000"),
+	},
+	{
+		def:  `[{"type": "bytes"}]`,
+		enc:  "000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200100000000000000000000000000000000000000000000000000000000000000",
+		want: [32]byte{},
+		err:  "abi: cannot unmarshal []uint8 in to [32]uint8",
 	},
 	{
 		def:  `[{"type": "bytes32"}]`,
@@ -126,13 +149,219 @@ var unpackTests = []unpackTest{
 		want: []byte(nil),
 		err:  "abi: cannot unmarshal [32]uint8 in to []uint8",
 	},
+	{
+		def:  `[{"type": "bytes32"}]`,
+		enc:  "0100000000000000000000000000000000000000000000000000000000000000",
+		want: [32]byte{1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+	},
+	{
+		def:  `[{"type": "function"}]`,
+		enc:  "0100000000000000000000000000000000000000000000000000000000000000",
+		want: [24]byte{1},
+	},
+	// slices
+	{
+		def:  `[{"type": "uint8[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []uint8{1, 2},
+	},
+	{
+		def:  `[{"type": "uint8[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]uint8{1, 2},
+	},
+	// multi dimensional, if these pass, all types that don't require length prefix should pass
+	{
+		def:  `[{"type": "uint8[][]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [][]uint8{{1, 2}, {1, 2}},
+	},
+	{
+		def:  `[{"type": "uint8[][]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003",
+		want: [][]uint8{{1, 2}, {1, 2, 3}},
+	},
+	{
+		def:  `[{"type": "uint8[2][2]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2][2]uint8{{1, 2}, {1, 2}},
+	},
+	{
+		def:  `[{"type": "uint8[][2]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001",
+		want: [2][]uint8{{1}, {1}},
+	},
+	{
+		def:  `[{"type": "uint8[2][]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [][2]uint8{{1, 2}},
+	},
+	{
+		def:  `[{"type": "uint8[2][]"}]`,
+		enc:  "000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [][2]uint8{{1, 2}, {1, 2}},
+	},
+	{
+		def:  `[{"type": "uint16[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []uint16{1, 2},
+	},
+	{
+		def:  `[{"type": "uint16[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]uint16{1, 2},
+	},
+	{
+		def:  `[{"type": "uint32[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []uint32{1, 2},
+	},
+	{
+		def:  `[{"type": "uint32[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]uint32{1, 2},
+	},
+	{
+		def:  `[{"type": "uint32[2][3][4]"}]`,
+		enc:  "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000009000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000b000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000d000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000110000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000001300000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000015000000000000000000000000000000000000000000000000000000000000001600000000000000000000000000000000000000000000000000000000000000170000000000000000000000000000000000000000000000000000000000000018",
+		want: [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}}},
+	},
+	{
+		def:  `[{"type": "uint64[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []uint64{1, 2},
+	},
+	{
+		def:  `[{"type": "uint64[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]uint64{1, 2},
+	},
+	{
+		def:  `[{"type": "uint256[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []*big.Int{big.NewInt(1), big.NewInt(2)},
+	},
+	{
+		def:  `[{"type": "uint256[3]"}]`,
+		enc:  "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003",
+		want: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
+	},
+	{
+		def:  `[{"type": "string[4]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000548656c6c6f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005576f726c64000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b476f2d657468657265756d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008457468657265756d000000000000000000000000000000000000000000000000",
+		want: [4]string{"Hello", "World", "Go-ethereum", "Ethereum"},
+	},
+	{
+		def:  `[{"type": "string[]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000008457468657265756d000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b676f2d657468657265756d000000000000000000000000000000000000000000",
+		want: []string{"Ethereum", "go-ethereum"},
+	},
+	{
+		def:  `[{"type": "bytes[]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000003f0f0f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003f0f0f00000000000000000000000000000000000000000000000000000000000",
+		want: [][]byte{{0xf0, 0xf0, 0xf0}, {0xf0, 0xf0, 0xf0}},
+	},
+	{
+		def:  `[{"type": "uint256[2][][]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000c8000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003e80000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000c8000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000003e8",
+		want: [][][2]*big.Int{{{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}, {{big.NewInt(1), big.NewInt(200)}, {big.NewInt(1), big.NewInt(1000)}}},
+	},
+	{
+		def:  `[{"type": "int8[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []int8{1, 2},
+	},
+	{
+		def:  `[{"type": "int8[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]int8{1, 2},
+	},
+	{
+		def:  `[{"type": "int16[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []int16{1, 2},
+	},
+	{
+		def:  `[{"type": "int16[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]int16{1, 2},
+	},
+	{
+		def:  `[{"type": "int32[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []int32{1, 2},
+	},
+	{
+		def:  `[{"type": "int32[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]int32{1, 2},
+	},
+	{
+		def:  `[{"type": "int64[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []int64{1, 2},
+	},
+	{
+		def:  `[{"type": "int64[2]"}]`,
+		enc:  "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: [2]int64{1, 2},
+	},
+	{
+		def:  `[{"type": "int256[]"}]`,
+		enc:  "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: []*big.Int{big.NewInt(1), big.NewInt(2)},
+	},
+	{
+		def:  `[{"type": "int256[3]"}]`,
+		enc:  "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003",
+		want: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)},
+	},
+	// struct outputs
+	{
+		def: `[{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}]`,
+		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: struct {
+			Int1 *big.Int
+			Int2 *big.Int
+		}{big.NewInt(1), big.NewInt(2)},
+	},
+	{
+		def: `[{"name":"int_one","type":"int256"}]`,
+		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: struct {
+			IntOne *big.Int
+		}{big.NewInt(1)},
+	},
+	{
+		def: `[{"name":"int__one","type":"int256"}]`,
+		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: struct {
+			IntOne *big.Int
+		}{big.NewInt(1)},
+	},
+	{
+		def: `[{"name":"int_one_","type":"int256"}]`,
+		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: struct {
+			IntOne *big.Int
+		}{big.NewInt(1)},
+	},
+	{
+		def: `[{"name":"int_one","type":"int256"}, {"name":"intone","type":"int256"}]`,
+		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
+		want: struct {
+			IntOne *big.Int
+			Intone *big.Int
+		}{big.NewInt(1), big.NewInt(2)},
+	},
 	{
 		def: `[{"name":"___","type":"int256"}]`,
 		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
 		want: struct {
 			IntOne *big.Int
 			Intone *big.Int
-		}{IntOne: big.NewInt(1)},
+		}{},
+		err: "abi: purely underscored output cannot unpack to struct",
 	},
 	{
 		def: `[{"name":"int_one","type":"int256"},{"name":"IntOne","type":"int256"}]`,
@@ -179,47 +408,22 @@ var unpackTests = []unpackTest{
 		}{},
 		err: "abi: purely underscored output cannot unpack to struct",
 	},
-	// Make sure only the first argument is consumed
-	{
-		def: `[{"name":"int_one","type":"int256"}]`,
-		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
-		want: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
-	{
-		def: `[{"name":"int__one","type":"int256"}]`,
-		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
-		want: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
-	{
-		def: `[{"name":"int_one_","type":"int256"}]`,
-		enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002",
-		want: struct {
-			IntOne *big.Int
-		}{big.NewInt(1)},
-	},
 }
 
-// TestLocalUnpackTests runs test specially designed only for unpacking.
-// All test cases that can be used to test packing and unpacking should move to packing_test.go
-func TestLocalUnpackTests(t *testing.T) {
+func TestUnpack(t *testing.T) {
 	for i, test := range unpackTests {
 		t.Run(strconv.Itoa(i), func(t *testing.T) {
-			//Unpack
-			def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
+			def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def)
 			abi, err := JSON(strings.NewReader(def))
 			if err != nil {
 				t.Fatalf("invalid ABI definition %s: %v", def, err)
 			}
 			encb, err := hex.DecodeString(test.enc)
 			if err != nil {
-				t.Fatalf("invalid hex %s: %v", test.enc, err)
+				t.Fatalf("invalid hex: %s" + test.enc)
 			}
 			outptr := reflect.New(reflect.TypeOf(test.want))
-			err = abi.UnpackIntoInterface(outptr.Interface(), "method", encb)
+			err = abi.Unpack(outptr.Interface(), "method", encb)
 			if err := test.checkError(err); err != nil {
 				t.Errorf("test %d (%v) failed: %v", i, test.def, err)
 				return
@@ -232,7 +436,7 @@ func TestLocalUnpackTests(t *testing.T) {
 	}
 }
 
-func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
+func TestUnpackSetDynamicArrayOutput(t *testing.T) {
 	abi, err := JSON(strings.NewReader(`[{"constant":true,"inputs":[],"name":"testDynamicFixedBytes15","outputs":[{"name":"","type":"bytes15[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"testDynamicFixedBytes32","outputs":[{"name":"","type":"bytes32[]"}],"payable":false,"stateMutability":"view","type":"function"}]`))
 	if err != nil {
 		t.Fatal(err)
@@ -247,7 +451,7 @@ func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
 	)
 
 	// test 32
-	err = abi.UnpackIntoInterface(&out32, "testDynamicFixedBytes32", marshalledReturn32)
+	err = abi.Unpack(&out32, "testDynamicFixedBytes32", marshalledReturn32)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -264,7 +468,7 @@ func TestUnpackIntoInterfaceSetDynamicArrayOutput(t *testing.T) {
 	}
 
 	// test 15
-	err = abi.UnpackIntoInterface(&out15, "testDynamicFixedBytes32", marshalledReturn15)
+	err = abi.Unpack(&out15, "testDynamicFixedBytes32", marshalledReturn15)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -288,7 +492,7 @@ type methodMultiOutput struct {
 
 func methodMultiReturn(require *require.Assertions) (ABI, []byte, methodMultiOutput) {
 	const definition = `[
-	{ "name" : "multi", "type": "function", "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]`
+	{ "name" : "multi", "constant" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]`
 	var expected = methodMultiOutput{big.NewInt(1), "hello"}
 
 	abi, err := JSON(strings.NewReader(definition))
@@ -308,11 +512,6 @@ func TestMethodMultiReturn(t *testing.T) {
 		Int    *big.Int
 	}
 
-	newInterfaceSlice := func(len int) interface{} {
-		slice := make([]interface{}, len)
-		return &slice
-	}
-
 	abi, data, expected := methodMultiReturn(require.New(t))
 	bigint := new(big.Int)
 	var testCases = []struct {
@@ -340,16 +539,6 @@ func TestMethodMultiReturn(t *testing.T) {
 		&[2]interface{}{&expected.Int, &expected.String},
 		"",
 		"Can unpack into an array",
-	}, {
-		&[2]interface{}{},
-		&[2]interface{}{expected.Int, expected.String},
-		"",
-		"Can unpack into interface array",
-	}, {
-		newInterfaceSlice(2),
-		&[]interface{}{expected.Int, expected.String},
-		"",
-		"Can unpack into interface slice",
 	}, {
 		&[]interface{}{new(int), new(int)},
 		&[]interface{}{&expected.Int, &expected.String},
@@ -358,14 +547,14 @@ func TestMethodMultiReturn(t *testing.T) {
 	}, {
 		&[]interface{}{new(int)},
 		&[]interface{}{},
-		"abi: insufficient number of arguments for unpack, want 2, got 1",
+		"abi: insufficient number of elements in the list/array for unpack, want 2, got 1",
 		"Can not unpack into a slice with wrong types",
 	}}
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
 			require := require.New(t)
-			err := abi.UnpackIntoInterface(tc.dest, "multi", data)
+			err := abi.Unpack(tc.dest, "multi", data)
 			if tc.error == "" {
 				require.Nil(err, "Should be able to unpack method outputs.")
 				require.Equal(tc.expected, tc.dest)
@@ -377,7 +566,7 @@ func TestMethodMultiReturn(t *testing.T) {
 }
 
 func TestMultiReturnWithArray(t *testing.T) {
-	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
+	const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Fatal(err)
@@ -388,7 +577,7 @@ func TestMultiReturnWithArray(t *testing.T) {
 
 	ret1, ret1Exp := new([3]uint64), [3]uint64{9, 9, 9}
 	ret2, ret2Exp := new(uint64), uint64(8)
-	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -400,7 +589,7 @@ func TestMultiReturnWithArray(t *testing.T) {
 }
 
 func TestMultiReturnWithStringArray(t *testing.T) {
-	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "uint256[3]"},{"name": "","type": "address"},{"name": "","type": "string[2]"},{"name": "","type": "bool"}]}]`
+	const definition = `[{"name" : "multi", "outputs": [{"name": "","type": "uint256[3]"},{"name": "","type": "address"},{"name": "","type": "string[2]"},{"name": "","type": "bool"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Fatal(err)
@@ -412,7 +601,7 @@ func TestMultiReturnWithStringArray(t *testing.T) {
 	ret2, ret2Exp := new(common.Address), common.HexToAddress("ab1257528b3782fb40d7ed5f72e624b744dffb2f")
 	ret3, ret3Exp := new([2]string), [2]string{"Ethereum", "Hello, Ethereum!"}
 	ret4, ret4Exp := new(bool), false
-	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2, ret3, ret4}, "multi", buff.Bytes()); err != nil {
+	if err := abi.Unpack(&[]interface{}{ret1, ret2, ret3, ret4}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -430,7 +619,7 @@ func TestMultiReturnWithStringArray(t *testing.T) {
 }
 
 func TestMultiReturnWithStringSlice(t *testing.T) {
-	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"name": "","type": "string[]"},{"name": "","type": "uint256[]"}]}]`
+	const definition = `[{"name" : "multi", "outputs": [{"name": "","type": "string[]"},{"name": "","type": "uint256[]"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Fatal(err)
@@ -450,7 +639,7 @@ func TestMultiReturnWithStringSlice(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000065")) // output[1][1] value
 	ret1, ret1Exp := new([]string), []string{"ethereum", "go-ethereum"}
 	ret2, ret2Exp := new([]*big.Int), []*big.Int{big.NewInt(100), big.NewInt(101)}
-	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -466,7 +655,7 @@ func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
 	//  values of nested static arrays count towards the size as well, and any element following
 	//  after such nested array argument should be read with the correct offset,
 	//  so that it does not read content from the previous array argument.
-	const definition = `[{"name" : "multi", "type": "function", "outputs": [{"type": "uint64[3][2][4]"}, {"type": "uint64"}]}]`
+	const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3][2][4]"}, {"type": "uint64"}]}]`
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
 		t.Fatal(err)
@@ -490,7 +679,7 @@ func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
 		{{0x411, 0x412, 0x413}, {0x421, 0x422, 0x423}},
 	}
 	ret2, ret2Exp := new(uint64), uint64(0x9876)
-	if err := abi.UnpackIntoInterface(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
+	if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil {
 		t.Fatal(err)
 	}
 	if !reflect.DeepEqual(*ret1, ret1Exp) {
@@ -503,15 +692,15 @@ func TestMultiReturnWithDeeplyNestedArray(t *testing.T) {
 
 func TestUnmarshal(t *testing.T) {
 	const definition = `[
-	{ "name" : "int", "type": "function", "outputs": [ { "type": "uint256" } ] },
-	{ "name" : "bool", "type": "function", "outputs": [ { "type": "bool" } ] },
-	{ "name" : "bytes", "type": "function", "outputs": [ { "type": "bytes" } ] },
-	{ "name" : "fixed", "type": "function", "outputs": [ { "type": "bytes32" } ] },
-	{ "name" : "multi", "type": "function", "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] },
-	{ "name" : "intArraySingle", "type": "function", "outputs": [ { "type": "uint256[3]" } ] },
-	{ "name" : "addressSliceSingle", "type": "function", "outputs": [ { "type": "address[]" } ] },
-	{ "name" : "addressSliceDouble", "type": "function", "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] },
-	{ "name" : "mixedBytes", "type": "function", "stateMutability" : "view", "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]`
+	{ "name" : "int", "constant" : false, "outputs": [ { "type": "uint256" } ] },
+	{ "name" : "bool", "constant" : false, "outputs": [ { "type": "bool" } ] },
+	{ "name" : "bytes", "constant" : false, "outputs": [ { "type": "bytes" } ] },
+	{ "name" : "fixed", "constant" : false, "outputs": [ { "type": "bytes32" } ] },
+	{ "name" : "multi", "constant" : false, "outputs": [ { "type": "bytes" }, { "type": "bytes" } ] },
+	{ "name" : "intArraySingle", "constant" : false, "outputs": [ { "type": "uint256[3]" } ] },
+	{ "name" : "addressSliceSingle", "constant" : false, "outputs": [ { "type": "address[]" } ] },
+	{ "name" : "addressSliceDouble", "constant" : false, "outputs": [ { "name": "a", "type": "address[]" }, { "name": "b", "type": "address[]" } ] },
+	{ "name" : "mixedBytes", "constant" : true, "outputs": [ { "name": "a", "type": "bytes" }, { "name": "b", "type": "bytes32" } ] }]`
 
 	abi, err := JSON(strings.NewReader(definition))
 	if err != nil {
@@ -529,7 +718,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000a"))
 	buff.Write(common.Hex2Bytes("0102000000000000000000000000000000000000000000000000000000000000"))
 
-	err = abi.UnpackIntoInterface(&mixedBytes, "mixedBytes", buff.Bytes())
+	err = abi.Unpack(&mixedBytes, "mixedBytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	} else {
@@ -544,7 +733,7 @@ func TestUnmarshal(t *testing.T) {
 
 	// marshal int
 	var Int *big.Int
-	err = abi.UnpackIntoInterface(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+	err = abi.Unpack(&Int, "int", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
 	if err != nil {
 		t.Error(err)
 	}
@@ -555,7 +744,7 @@ func TestUnmarshal(t *testing.T) {
 
 	// marshal bool
 	var Bool bool
-	err = abi.UnpackIntoInterface(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
+	err = abi.Unpack(&Bool, "bool", common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001"))
 	if err != nil {
 		t.Error(err)
 	}
@@ -572,7 +761,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(bytesOut)
 
 	var Bytes []byte
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -588,7 +777,7 @@ func TestUnmarshal(t *testing.T) {
 	bytesOut = common.RightPadBytes([]byte("hello"), 64)
 	buff.Write(bytesOut)
 
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -604,7 +793,7 @@ func TestUnmarshal(t *testing.T) {
 	bytesOut = common.RightPadBytes([]byte("hello"), 64)
 	buff.Write(bytesOut)
 
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -614,7 +803,7 @@ func TestUnmarshal(t *testing.T) {
 	}
 
 	// marshal dynamic bytes output empty
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", nil)
+	err = abi.Unpack(&Bytes, "bytes", nil)
 	if err == nil {
 		t.Error("expected error")
 	}
@@ -625,7 +814,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005"))
 	buff.Write(common.RightPadBytes([]byte("hello"), 32))
 
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -639,7 +828,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.RightPadBytes([]byte("hello"), 32))
 
 	var hash common.Hash
-	err = abi.UnpackIntoInterface(&hash, "fixed", buff.Bytes())
+	err = abi.Unpack(&hash, "fixed", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -652,12 +841,12 @@ func TestUnmarshal(t *testing.T) {
 	// marshal error
 	buff.Reset()
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000020"))
-	err = abi.UnpackIntoInterface(&Bytes, "bytes", buff.Bytes())
+	err = abi.Unpack(&Bytes, "bytes", buff.Bytes())
 	if err == nil {
 		t.Error("expected error")
 	}
 
-	err = abi.UnpackIntoInterface(&Bytes, "multi", make([]byte, 64))
+	err = abi.Unpack(&Bytes, "multi", make([]byte, 64))
 	if err == nil {
 		t.Error("expected error")
 	}
@@ -668,7 +857,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000003"))
 	// marshal int array
 	var intArray [3]*big.Int
-	err = abi.UnpackIntoInterface(&intArray, "intArraySingle", buff.Bytes())
+	err = abi.Unpack(&intArray, "intArraySingle", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -689,7 +878,7 @@ func TestUnmarshal(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000100000000000000000000000000000000000000"))
 
 	var outAddr []common.Address
-	err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
+	err = abi.Unpack(&outAddr, "addressSliceSingle", buff.Bytes())
 	if err != nil {
 		t.Fatal("didn't expect error:", err)
 	}
@@ -716,7 +905,7 @@ func TestUnmarshal(t *testing.T) {
 		A []common.Address
 		B []common.Address
 	}
-	err = abi.UnpackIntoInterface(&outAddrStruct, "addressSliceDouble", buff.Bytes())
+	err = abi.Unpack(&outAddrStruct, "addressSliceDouble", buff.Bytes())
 	if err != nil {
 		t.Fatal("didn't expect error:", err)
 	}
@@ -744,14 +933,14 @@ func TestUnmarshal(t *testing.T) {
 	buff.Reset()
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000100"))
 
-	err = abi.UnpackIntoInterface(&outAddr, "addressSliceSingle", buff.Bytes())
+	err = abi.Unpack(&outAddr, "addressSliceSingle", buff.Bytes())
 	if err == nil {
 		t.Fatal("expected error:", err)
 	}
 }
 
 func TestUnpackTuple(t *testing.T) {
-	const simpleTuple = `[{"name":"tuple","type":"function","outputs":[{"type":"tuple","name":"ret","components":[{"type":"int256","name":"a"},{"type":"int256","name":"b"}]}]}]`
+	const simpleTuple = `[{"name":"tuple","constant":false,"outputs":[{"type":"tuple","name":"ret","components":[{"type":"int256","name":"a"},{"type":"int256","name":"b"}]}]}]`
 	abi, err := JSON(strings.NewReader(simpleTuple))
 	if err != nil {
 		t.Fatal(err)
@@ -761,26 +950,30 @@ func TestUnpackTuple(t *testing.T) {
 	buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) // ret[a] = 1
 	buff.Write(common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) // ret[b] = -1
 
-	// If the result is single tuple, use struct as return value container directly.
 	v := struct {
+		Ret struct {
 			A *big.Int
 			B *big.Int
-	}{new(big.Int), new(big.Int)}
+		}
+	}{Ret: struct {
+		A *big.Int
+		B *big.Int
+	}{new(big.Int), new(big.Int)}}
 
-	err = abi.UnpackIntoInterface(&v, "tuple", buff.Bytes())
+	err = abi.Unpack(&v, "tuple", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	} else {
-		if v.A.Cmp(big.NewInt(1)) != 0 {
-			t.Errorf("unexpected value unpacked: want %x, got %x", 1, v.A)
+		if v.Ret.A.Cmp(big.NewInt(1)) != 0 {
+			t.Errorf("unexpected value unpacked: want %x, got %x", 1, v.Ret.A)
 		}
-		if v.B.Cmp(big.NewInt(-1)) != 0 {
-			t.Errorf("unexpected value unpacked: want %x, got %x", -1, v.B)
+		if v.Ret.B.Cmp(big.NewInt(-1)) != 0 {
+			t.Errorf("unexpected value unpacked: want %x, got %x", v.Ret.B, -1)
 		}
 	}
 
 	// Test nested tuple
-	const nestedTuple = `[{"name":"tuple","type":"function","outputs":[
+	const nestedTuple = `[{"name":"tuple","constant":false,"outputs":[
 		{"type":"tuple","name":"s","components":[{"type":"uint256","name":"a"},{"type":"uint256[]","name":"b"},{"type":"tuple[]","name":"c","components":[{"name":"x", "type":"uint256"},{"name":"y","type":"uint256"}]}]},
 		{"type":"tuple","name":"t","components":[{"name":"x", "type":"uint256"},{"name":"y","type":"uint256"}]},
 		{"type":"uint256","name":"a"}
@@ -839,7 +1032,7 @@ func TestUnpackTuple(t *testing.T) {
 		A: big.NewInt(1),
 	}
 
-	err = abi.UnpackIntoInterface(&ret, "tuple", buff.Bytes())
+	err = abi.Unpack(&ret, "tuple", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	}
@@ -902,7 +1095,7 @@ func TestOOMMaliciousInput(t *testing.T) {
 		},
 	}
 	for i, test := range oomTests {
-		def := fmt.Sprintf(`[{ "name" : "method", "type": "function", "outputs": %s}]`, test.def)
+		def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def)
 		abi, err := JSON(strings.NewReader(def))
 		if err != nil {
 			t.Fatalf("invalid ABI definition %s: %v", def, err)

accounts/accounts.go

@@ -18,14 +18,12 @@
 package accounts
 
 import (
-	"fmt"
 	"math/big"
 
-	"github.com/ethereum/go-ethereum"
+	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/event"
-	"golang.org/x/crypto/sha3"
 )
 
 // Account represents an Ethereum account located at a specific location defined
@@ -35,13 +33,6 @@ type Account struct {
 	URL     URL            `json:"url"`     // Optional resource locator within a backend
 }
 
-const (
-	MimetypeDataWithValidator = "data/validator"
-	MimetypeTypedData         = "data/typed"
-	MimetypeClique            = "application/x-clique-header"
-	MimetypeTextPlain         = "text/plain"
-)
-
 // Wallet represents a software or hardware wallet that might contain one or more
 // accounts (derived from the same seed).
 type Wallet interface {
@@ -88,38 +79,16 @@ type Wallet interface {
 	// to discover non zero accounts and automatically add them to list of tracked
 	// accounts.
 	//
-	// Note, self derivation will increment the last component of the specified path
+	// Note, self derivaton will increment the last component of the specified path
 	// opposed to decending into a child path to allow discovering accounts starting
 	// from non zero components.
 	//
-	// Some hardware wallets switched derivation paths through their evolution, so
-	// this method supports providing multiple bases to discover old user accounts
-	// too. Only the last base will be used to derive the next empty account.
-	//
 	// You can disable automatic account discovery by calling SelfDerive with a nil
 	// chain state reader.
-	SelfDerive(bases []DerivationPath, chain ethereum.ChainStateReader)
+	SelfDerive(base DerivationPath, chain ethereum.ChainStateReader)
 
-	// SignData requests the wallet to sign the hash of the given data
-	// It looks up the account specified either solely via its address contained within,
-	// or optionally with the aid of any location metadata from the embedded URL field.
+	// SignHash requests the wallet to sign the given hash.
 	//
-	// If the wallet requires additional authentication to sign the request (e.g.
-	// a password to decrypt the account, or a PIN code o verify the transaction),
-	// an AuthNeededError instance will be returned, containing infos for the user
-	// about which fields or actions are needed. The user may retry by providing
-	// the needed details via SignDataWithPassphrase, or by other means (e.g. unlock
-	// the account in a keystore).
-	SignData(account Account, mimeType string, data []byte) ([]byte, error)
-
-	// SignDataWithPassphrase is identical to SignData, but also takes a password
-	// NOTE: there's an chance that an erroneous call might mistake the two strings, and
-	// supply password in the mimetype field, or vice versa. Thus, an implementation
-	// should never echo the mimetype or return the mimetype in the error-response
-	SignDataWithPassphrase(account Account, passphrase, mimeType string, data []byte) ([]byte, error)
-
-	// SignText requests the wallet to sign the hash of a given piece of data, prefixed
-	// by the Ethereum prefix scheme
 	// It looks up the account specified either solely via its address contained within,
 	// or optionally with the aid of any location metadata from the embedded URL field.
 	//
@@ -129,12 +98,7 @@ type Wallet interface {
 	// about which fields or actions are needed. The user may retry by providing
 	// the needed details via SignHashWithPassphrase, or by other means (e.g. unlock
 	// the account in a keystore).
-	//
-	// This method should return the signature in 'canonical' format, with v 0 or 1
-	SignText(account Account, text []byte) ([]byte, error)
-
-	// SignTextWithPassphrase is identical to Signtext, but also takes a password
-	SignTextWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
+	SignHash(account Account, hash []byte) ([]byte, error)
 
 	// SignTx requests the wallet to sign the given transaction.
 	//
@@ -149,7 +113,18 @@ type Wallet interface {
 	// the account in a keystore).
 	SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
 
-	// SignTxWithPassphrase is identical to SignTx, but also takes a password
+	// SignHashWithPassphrase requests the wallet to sign the given hash with the
+	// given passphrase as extra authentication information.
+	//
+	// It looks up the account specified either solely via its address contained within,
+	// or optionally with the aid of any location metadata from the embedded URL field.
+	SignHashWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
+
+	// SignTxWithPassphrase requests the wallet to sign the given transaction, with the
+	// given passphrase as extra authentication information.
+	//
+	// It looks up the account specified either solely via its address contained within,
+	// or optionally with the aid of any location metadata from the embedded URL field.
 	SignTxWithPassphrase(account Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
 }
 
@@ -173,32 +148,6 @@ type Backend interface {
 	Subscribe(sink chan<- WalletEvent) event.Subscription
 }
 
-// TextHash is a helper function that calculates a hash for the given message that can be
-// safely used to calculate a signature from.
-//
-// The hash is calulcated as
-//   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
-//
-// This gives context to the signed message and prevents signing of transactions.
-func TextHash(data []byte) []byte {
-	hash, _ := TextAndHash(data)
-	return hash
-}
-
-// TextAndHash is a helper function that calculates a hash for the given message that can be
-// safely used to calculate a signature from.
-//
-// The hash is calulcated as
-//   keccak256("\x19Ethereum Signed Message:\n"${message length}${message}).
-//
-// This gives context to the signed message and prevents signing of transactions.
-func TextAndHash(data []byte) ([]byte, string) {
-	msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), string(data))
-	hasher := sha3.NewLegacyKeccak256()
-	hasher.Write([]byte(msg))
-	return hasher.Sum(nil), msg
-}
-
 // WalletEventType represents the different event types that can be fired by
 // the wallet subscription subsystem.
 type WalletEventType int

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)
-	}
-}

accounts/errors.go

@@ -35,7 +35,7 @@ var ErrNotSupported = errors.New("not supported")
 
 // ErrInvalidPassphrase is returned when a decryption operation receives a bad
 // passphrase.
-var ErrInvalidPassphrase = errors.New("invalid password")
+var ErrInvalidPassphrase = errors.New("invalid passphrase")
 
 // ErrWalletAlreadyOpen is returned if a wallet is attempted to be opened the
 // second time.

accounts/external/backend.go

@@ -1,247 +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/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()
-	if api.cache == nil {
-		// If we haven't already fetched the accounts, it's time to do so now
-		api.cacheMu.RUnlock()
-		api.Accounts()
-		api.cacheMu.RLock()
-	}
-	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 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 signature hexutil.Bytes
-	var signAddress = common.NewMixedcaseAddress(account.Address)
-	if err := api.client.Call(&signature, "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
-	}
-	if signature[64] == 27 || signature[64] == 28 {
-		// If clef is used as a backend, it may already have transformed
-		// the signature to ethereum-type signature.
-		signature[64] -= 27 // Transform V from Ethereum-legacy to 0/1
-	}
-	return signature, nil
-}
-
-// signTransactionResult represents the signinig result returned by clef.
-type signTransactionResult struct {
-	Raw hexutil.Bytes      `json:"raw"`
-	Tx  *types.Transaction `json:"tx"`
-}
-
-func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
-	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),
-	}
-	var res signTransactionResult
-	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
-}

accounts/hd.go

@@ -17,7 +17,6 @@
 package accounts
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"math"
@@ -35,10 +34,10 @@ var DefaultRootDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60,
 // at m/44'/60'/0'/0/1, etc.
 var DefaultBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0, 0}
 
-// LegacyLedgerBaseDerivationPath is the legacy base path from which custom derivation
-// endpoints are incremented. As such, the first account will be at m/44'/60'/0'/0, the
-// second at m/44'/60'/0'/1, etc.
-var LegacyLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
+// DefaultLedgerBaseDerivationPath is the base path from which custom derivation endpoints
+// are incremented. As such, the first account will be at m/44'/60'/0'/0, the second
+// at m/44'/60'/0'/1, etc.
+var DefaultLedgerBaseDerivationPath = DerivationPath{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
 
 // DerivationPath represents the computer friendly version of a hierarchical
 // deterministic wallet account derivaion path.
@@ -134,47 +133,3 @@ func (path DerivationPath) String() string {
 	}
 	return result
 }
-
-// MarshalJSON turns a derivation path into its json-serialized string
-func (path DerivationPath) MarshalJSON() ([]byte, error) {
-	return json.Marshal(path.String())
-}
-
-// UnmarshalJSON a json-serialized string back into a derivation path
-func (path *DerivationPath) UnmarshalJSON(b []byte) error {
-	var dp string
-	var err error
-	if err = json.Unmarshal(b, &dp); err != nil {
-		return err
-	}
-	*path, err = ParseDerivationPath(dp)
-	return err
-}
-
-// DefaultIterator creates a BIP-32 path iterator, which progresses by increasing the last component:
-// i.e. m/44'/60'/0'/0/0, m/44'/60'/0'/0/1, m/44'/60'/0'/0/2, ... m/44'/60'/0'/0/N.
-func DefaultIterator(base DerivationPath) func() DerivationPath {
-	path := make(DerivationPath, len(base))
-	copy(path[:], base[:])
-	// Set it back by one, so the first call gives the first result
-	path[len(path)-1]--
-	return func() DerivationPath {
-		path[len(path)-1]++
-		return path
-	}
-}
-
-// LedgerLiveIterator creates a bip44 path iterator for Ledger Live.
-// Ledger Live increments the third component rather than the fifth component
-// i.e. m/44'/60'/0'/0/0, m/44'/60'/1'/0/0, m/44'/60'/2'/0/0, ... m/44'/60'/N'/0/0.
-func LedgerLiveIterator(base DerivationPath) func() DerivationPath {
-	path := make(DerivationPath, len(base))
-	copy(path[:], base[:])
-	// Set it back by one, so the first call gives the first result
-	path[2]--
-	return func() DerivationPath {
-		// ledgerLivePathIterator iterates on the third component
-		path[2]++
-		return path
-	}
-}

accounts/hd_test.go

@@ -17,7 +17,6 @@
 package accounts
 
 import (
-	"fmt"
 	"reflect"
 	"testing"
 )
@@ -62,7 +61,7 @@ func TestHDPathParsing(t *testing.T) {
 		// 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}},
 
-		// Invalid derivation paths
+		// Invaid derivation paths
 		{"", nil},              // Empty relative derivation path
 		{"m", nil},             // Empty absolute derivation path
 		{"m/", nil},            // Missing last derivation component
@@ -78,41 +77,3 @@ func TestHDPathParsing(t *testing.T) {
 		}
 	}
 }
-
-func testDerive(t *testing.T, next func() DerivationPath, expected []string) {
-	t.Helper()
-	for i, want := range expected {
-		if have := next(); fmt.Sprintf("%v", have) != want {
-			t.Errorf("step %d, have %v, want %v", i, have, want)
-		}
-	}
-}
-
-func TestHdPathIteration(t *testing.T) {
-	testDerive(t, DefaultIterator(DefaultBaseDerivationPath),
-		[]string{
-			"m/44'/60'/0'/0/0", "m/44'/60'/0'/0/1",
-			"m/44'/60'/0'/0/2", "m/44'/60'/0'/0/3",
-			"m/44'/60'/0'/0/4", "m/44'/60'/0'/0/5",
-			"m/44'/60'/0'/0/6", "m/44'/60'/0'/0/7",
-			"m/44'/60'/0'/0/8", "m/44'/60'/0'/0/9",
-		})
-
-	testDerive(t, DefaultIterator(LegacyLedgerBaseDerivationPath),
-		[]string{
-			"m/44'/60'/0'/0", "m/44'/60'/0'/1",
-			"m/44'/60'/0'/2", "m/44'/60'/0'/3",
-			"m/44'/60'/0'/4", "m/44'/60'/0'/5",
-			"m/44'/60'/0'/6", "m/44'/60'/0'/7",
-			"m/44'/60'/0'/8", "m/44'/60'/0'/9",
-		})
-
-	testDerive(t, LedgerLiveIterator(DefaultBaseDerivationPath),
-		[]string{
-			"m/44'/60'/0'/0/0", "m/44'/60'/1'/0/0",
-			"m/44'/60'/2'/0/0", "m/44'/60'/3'/0/0",
-			"m/44'/60'/4'/0/0", "m/44'/60'/5'/0/0",
-			"m/44'/60'/6'/0/0", "m/44'/60'/7'/0/0",
-			"m/44'/60'/8'/0/0", "m/44'/60'/9'/0/0",
-		})
-}

accounts/keystore/account_cache.go

@@ -262,7 +262,7 @@ func (ac *accountCache) scanAccounts() error {
 		switch {
 		case err != nil:
 			log.Debug("Failed to decode keystore key", "path", path, "err", err)
-		case addr == common.Address{}:
+		case (addr == common.Address{}):
 			log.Debug("Failed to decode keystore key", "path", path, "err", "missing or zero address")
 		default:
 			return &accounts.Account{

accounts/keystore/file_cache.go

@@ -32,7 +32,7 @@ import (
 type fileCache struct {
 	all     mapset.Set // Set of all files from the keystore folder
 	lastMod time.Time  // Last time instance when a file was modified
-	mu      sync.Mutex
+	mu      sync.RWMutex
 }
 
 // scan performs a new scan on the given directory, compares against the already

accounts/keystore/key.go

@@ -32,7 +32,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/google/uuid"
+	"github.com/pborman/uuid"
 )
 
 const (
@@ -110,10 +110,7 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) {
 	}
 
 	u := new(uuid.UUID)
-	*u, err = uuid.Parse(keyJSON.Id)
-	if err != nil {
-		return err
-	}
+	*u = uuid.Parse(keyJSON.Id)
 	k.Id = *u
 	addr, err := hex.DecodeString(keyJSON.Address)
 	if err != nil {
@@ -131,10 +128,7 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) {
 }
 
 func newKeyFromECDSA(privateKeyECDSA *ecdsa.PrivateKey) *Key {
-	id, err := uuid.NewRandom()
-	if err != nil {
-		panic(fmt.Sprintf("Could not create random uuid: %v", err))
-	}
+	id := uuid.NewRandom()
 	key := &Key{
 		Id:         id,
 		Address:    crypto.PubkeyToAddress(privateKeyECDSA.PublicKey),

accounts/keystore/keystore.go

@@ -24,6 +24,7 @@ import (
 	"crypto/ecdsa"
 	crand "crypto/rand"
 	"errors"
+	"fmt"
 	"math/big"
 	"os"
 	"path/filepath"
@@ -42,11 +43,7 @@ import (
 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")
-
-	// ErrAccountAlreadyExists is returned if an account attempted to import is
-	// already present in the keystore.
-	ErrAccountAlreadyExists = errors.New("account already exists")
+	ErrDecrypt = errors.New("could not decrypt key with given passphrase")
 )
 
 // KeyStoreType is the reflect type of a keystore backend.
@@ -71,7 +68,6 @@ type KeyStore struct {
 	updating    bool                    // Whether the event notification loop is running
 
 	mu sync.RWMutex
-	importMu sync.Mutex // Import Mutex locks the import to prevent two insertions from racing
 }
 
 type unlocked struct {
@@ -141,10 +137,8 @@ func (ks *KeyStore) refreshWallets() {
 	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
-	)
+	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
@@ -283,9 +277,11 @@ func (ks *KeyStore) SignTx(a accounts.Account, tx *types.Transaction, chainID *b
 	if !found {
 		return nil, ErrLocked
 	}
-	// Depending on the presence of the chain ID, sign with 2718 or homestead
-	signer := types.LatestSignerForChainID(chainID)
-	return types.SignTx(tx, signer, unlockedKey.PrivateKey)
+	// 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
@@ -308,9 +304,12 @@ func (ks *KeyStore) SignTxWithPassphrase(a accounts.Account, passphrase string,
 		return nil, err
 	}
 	defer zeroKey(key.PrivateKey)
-	// Depending on the presence of the chain ID, sign with or without replay protection.
-	signer := types.LatestSignerForChainID(chainID)
-	return types.SignTx(tx, signer, 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.
@@ -442,27 +441,14 @@ func (ks *KeyStore) Import(keyJSON []byte, passphrase, newPassphrase string) (ac
 	if err != nil {
 		return accounts.Account{}, err
 	}
-	ks.importMu.Lock()
-	defer ks.importMu.Unlock()
-
-	if ks.cache.hasAddress(key.Address) {
-		return accounts.Account{
-			Address: key.Address,
-		}, ErrAccountAlreadyExists
-	}
 	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) {
-	ks.importMu.Lock()
-	defer ks.importMu.Unlock()
-
 	key := newKeyFromECDSA(priv)
 	if ks.cache.hasAddress(key.Address) {
-		return accounts.Account{
-			Address: key.Address,
-		}, ErrAccountAlreadyExists
+		return accounts.Account{}, fmt.Errorf("account already exists")
 	}
 	return ks.importKey(key, passphrase)
 }

accounts/keystore/keystore_test.go

@@ -23,14 +23,11 @@ import (
 	"runtime"
 	"sort"
 	"strings"
-	"sync"
-	"sync/atomic"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/event"
 )
 
@@ -336,95 +333,11 @@ func TestWalletNotifications(t *testing.T) {
 
 	// Shut down the event collector and check events.
 	sub.Unsubscribe()
-	for ev := range updates {
-		events = append(events, walletEvent{ev, ev.Wallet.Accounts()[0]})
-	}
+	<-updates
 	checkAccounts(t, live, ks.Wallets())
 	checkEvents(t, wantEvents, events)
 }
 
-// TestImportExport tests the import functionality of a keystore.
-func TestImportECDSA(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		t.Fatalf("failed to generate key: %v", key)
-	}
-	if _, err = ks.ImportECDSA(key, "old"); err != nil {
-		t.Errorf("importing failed: %v", err)
-	}
-	if _, err = ks.ImportECDSA(key, "old"); err == nil {
-		t.Errorf("importing same key twice succeeded")
-	}
-	if _, err = ks.ImportECDSA(key, "new"); err == nil {
-		t.Errorf("importing same key twice succeeded")
-	}
-}
-
-// TestImportECDSA tests the import and export functionality of a keystore.
-func TestImportExport(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-	acc, err := ks.NewAccount("old")
-	if err != nil {
-		t.Fatalf("failed to create account: %v", acc)
-	}
-	json, err := ks.Export(acc, "old", "new")
-	if err != nil {
-		t.Fatalf("failed to export account: %v", acc)
-	}
-	dir2, ks2 := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir2)
-	if _, err = ks2.Import(json, "old", "old"); err == nil {
-		t.Errorf("importing with invalid password succeeded")
-	}
-	acc2, err := ks2.Import(json, "new", "new")
-	if err != nil {
-		t.Errorf("importing failed: %v", err)
-	}
-	if acc.Address != acc2.Address {
-		t.Error("imported account does not match exported account")
-	}
-	if _, err = ks2.Import(json, "new", "new"); err == nil {
-		t.Errorf("importing a key twice succeeded")
-	}
-
-}
-
-// TestImportRace tests the keystore on races.
-// This test should fail under -race if importing races.
-func TestImportRace(t *testing.T) {
-	dir, ks := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir)
-	acc, err := ks.NewAccount("old")
-	if err != nil {
-		t.Fatalf("failed to create account: %v", acc)
-	}
-	json, err := ks.Export(acc, "old", "new")
-	if err != nil {
-		t.Fatalf("failed to export account: %v", acc)
-	}
-	dir2, ks2 := tmpKeyStore(t, true)
-	defer os.RemoveAll(dir2)
-	var atom uint32
-	var wg sync.WaitGroup
-	wg.Add(2)
-	for i := 0; i < 2; i++ {
-		go func() {
-			defer wg.Done()
-			if _, err := ks2.Import(json, "new", "new"); err != nil {
-				atomic.AddUint32(&atom, 1)
-			}
-
-		}()
-	}
-	wg.Wait()
-	if atom != 1 {
-		t.Errorf("Import is racy")
-	}
-}
-
 // 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) {
@@ -466,9 +379,9 @@ func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	newKs := NewPlaintextKeyStore
+	new := NewPlaintextKeyStore
 	if encrypted {
-		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
+		new = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }
 	}
-	return d, newKs(d)
+	return d, new(d)
 }

accounts/keystore/passphrase.go

@@ -38,11 +38,10 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/google/uuid"
+	"github.com/pborman/uuid"
 	"golang.org/x/crypto/pbkdf2"
 	"golang.org/x/crypto/scrypt"
 )
@@ -98,9 +97,9 @@ func (ks keyStorePassphrase) GetKey(addr common.Address, filename, auth string)
 }
 
 // StoreKey generates a key, encrypts with 'auth' and stores in the given directory
-func StoreKey(dir, auth string, scryptN, scryptP int) (accounts.Account, error) {
+func StoreKey(dir, auth string, scryptN, scryptP int) (common.Address, error) {
 	_, a, err := storeNewKey(&keyStorePassphrase{dir, scryptN, scryptP, false}, rand.Reader, auth)
-	return a, err
+	return a.Address, err
 }
 
 func (ks keyStorePassphrase) StoreKey(filename string, key *Key, auth string) error {
@@ -123,7 +122,6 @@ func (ks keyStorePassphrase) StoreKey(filename string, key *Key, auth string) er
 				"Please file a ticket at:\n\n" +
 				"https://github.com/ethereum/go-ethereum/issues." +
 				"The error was : %s"
-			//lint:ignore ST1005 This is a message for the user
 			return fmt.Errorf(msg, tmpName, err)
 		}
 	}
@@ -228,12 +226,9 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) {
 		return nil, err
 	}
 	key := crypto.ToECDSAUnsafe(keyBytes)
-	id, err := uuid.FromBytes(keyId)
-	if err != nil {
-		return nil, err
-	}
+
 	return &Key{
-		Id:         id,
+		Id:         uuid.UUID(keyId),
 		Address:    crypto.PubkeyToAddress(key.PublicKey),
 		PrivateKey: key,
 	}, nil
@@ -241,7 +236,7 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) {
 
 func DecryptDataV3(cryptoJson CryptoJSON, auth string) ([]byte, error) {
 	if cryptoJson.Cipher != "aes-128-ctr" {
-		return nil, fmt.Errorf("cipher not supported: %v", cryptoJson.Cipher)
+		return nil, fmt.Errorf("Cipher not supported: %v", cryptoJson.Cipher)
 	}
 	mac, err := hex.DecodeString(cryptoJson.MAC)
 	if err != nil {
@@ -277,13 +272,9 @@ func DecryptDataV3(cryptoJson CryptoJSON, auth string) ([]byte, error) {
 
 func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byte, keyId []byte, err error) {
 	if keyProtected.Version != version {
-		return nil, nil, fmt.Errorf("version not supported: %v", keyProtected.Version)
+		return nil, nil, fmt.Errorf("Version not supported: %v", keyProtected.Version)
 	}
-	keyUUID, err := uuid.Parse(keyProtected.Id)
-	if err != nil {
-		return nil, nil, err
-	}
-	keyId = keyUUID[:]
+	keyId = uuid.Parse(keyProtected.Id)
 	plainText, err := DecryptDataV3(keyProtected.Crypto, auth)
 	if err != nil {
 		return nil, nil, err
@@ -292,11 +283,7 @@ func decryptKeyV3(keyProtected *encryptedKeyJSONV3, auth string) (keyBytes []byt
 }
 
 func decryptKeyV1(keyProtected *encryptedKeyJSONV1, auth string) (keyBytes []byte, keyId []byte, err error) {
-	keyUUID, err := uuid.Parse(keyProtected.Id)
-	if err != nil {
-		return nil, nil, err
-	}
-	keyId = keyUUID[:]
+	keyId = uuid.Parse(keyProtected.Id)
 	mac, err := hex.DecodeString(keyProtected.Crypto.MAC)
 	if err != nil {
 		return nil, nil, err
@@ -347,13 +334,13 @@ func getKDFKey(cryptoJSON CryptoJSON, auth string) ([]byte, error) {
 		c := ensureInt(cryptoJSON.KDFParams["c"])
 		prf := cryptoJSON.KDFParams["prf"].(string)
 		if prf != "hmac-sha256" {
-			return nil, fmt.Errorf("unsupported PBKDF2 PRF: %s", prf)
+			return nil, fmt.Errorf("Unsupported PBKDF2 PRF: %s", prf)
 		}
 		key := pbkdf2.Key(authArray, salt, c, dkLen, sha256.New)
 		return key, nil
 	}
 
-	return nil, fmt.Errorf("unsupported KDF: %s", cryptoJSON.KDF)
+	return nil, fmt.Errorf("Unsupported KDF: %s", cryptoJSON.KDF)
 }
 
 // TODO: can we do without this when unmarshalling dynamic JSON?

accounts/keystore/plain_test.go

@@ -96,7 +96,7 @@ func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
 		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)
+		t.Fatalf("wrong error for invalid passphrase\ngot %q\nwant %q", err, ErrDecrypt)
 	}
 }
 

accounts/keystore/presale.go

@@ -27,7 +27,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/google/uuid"
+	"github.com/pborman/uuid"
 	"golang.org/x/crypto/pbkdf2"
 )
 
@@ -37,10 +37,7 @@ func importPreSaleKey(keyStore keyStore, keyJSON []byte, password string) (accou
 	if err != nil {
 		return accounts.Account{}, nil, err
 	}
-	key.Id, err = uuid.NewRandom()
-	if err != nil {
-		return accounts.Account{}, nil, err
-	}
+	key.Id = uuid.NewRandom()
 	a := accounts.Account{
 		Address: key.Address,
 		URL: accounts.URL{
@@ -89,7 +86,7 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error
 	ecKey := crypto.ToECDSAUnsafe(ethPriv)
 
 	key = &Key{
-		Id:         uuid.UUID{},
+		Id:         nil,
 		Address:    crypto.PubkeyToAddress(ecKey.PublicKey),
 		PrivateKey: ecKey,
 	}

accounts/keystore/testdata/keystore/README

@@ -1,5 +1,5 @@
 This directory contains accounts for testing.
-The password that unlocks them is "foobar".
+The passphrase that unlocks them is "foobar".
 
 The "good" key files which are supposed to be loadable are:
 

accounts/keystore/wallet.go

@@ -19,10 +19,9 @@ package keystore
 import (
 	"math/big"
 
-	"github.com/ethereum/go-ethereum"
+	ethereum "github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
 )
 
 // keystoreWallet implements the accounts.Wallet interface for the original
@@ -58,7 +57,7 @@ func (w *keystoreWallet) Open(passphrase string) error { return nil }
 func (w *keystoreWallet) Close() error { return nil }
 
 // Accounts implements accounts.Wallet, returning an account list consisting of
-// a single account that the plain keystore wallet contains.
+// a single account that the plain kestore wallet contains.
 func (w *keystoreWallet) Accounts() []accounts.Account {
 	return []accounts.Account{w.account}
 }
@@ -77,14 +76,13 @@ func (w *keystoreWallet) Derive(path accounts.DerivationPath, pin bool) (account
 
 // SelfDerive implements accounts.Wallet, but is a noop for plain wallets since
 // there is no notion of hierarchical account derivation for plain keystore accounts.
-func (w *keystoreWallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
-}
+func (w *keystoreWallet) SelfDerive(base accounts.DerivationPath, chain ethereum.ChainStateReader) {}
 
-// signHash attempts to sign the given hash with
+// SignHash implements accounts.Wallet, attempting to sign the given hash with
 // the given account. If the wallet does not wrap this particular account, an
 // error is returned to avoid account leakage (even though in theory we may be
 // able to sign via our shared keystore backend).
-func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
+func (w *keystoreWallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) {
 	// Make sure the requested account is contained within
 	if !w.Contains(account) {
 		return nil, accounts.ErrUnknownAccount
@@ -93,38 +91,6 @@ func (w *keystoreWallet) signHash(account accounts.Account, hash []byte) ([]byte
 	return w.keystore.SignHash(account, hash)
 }
 
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed.
-func (w *keystoreWallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
-	return w.signHash(account, crypto.Keccak256(data))
-}
-
-// SignDataWithPassphrase signs keccak256(data). The mimetype parameter describes the type of data being signed.
-func (w *keystoreWallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
-	// Make sure the requested account is contained within
-	if !w.Contains(account) {
-		return nil, accounts.ErrUnknownAccount
-	}
-	// Account seems valid, request the keystore to sign
-	return w.keystore.SignHashWithPassphrase(account, passphrase, crypto.Keccak256(data))
-}
-
-// SignText implements accounts.Wallet, attempting to sign the hash of
-// the given text with the given account.
-func (w *keystoreWallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
-	return w.signHash(account, accounts.TextHash(text))
-}
-
-// SignTextWithPassphrase implements accounts.Wallet, attempting to sign the
-// hash of the given text with the given account using passphrase as extra authentication.
-func (w *keystoreWallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
-	// Make sure the requested account is contained within
-	if !w.Contains(account) {
-		return nil, accounts.ErrUnknownAccount
-	}
-	// Account seems valid, request the keystore to sign
-	return w.keystore.SignHashWithPassphrase(account, passphrase, accounts.TextHash(text))
-}
-
 // SignTx implements accounts.Wallet, attempting to sign the given transaction
 // with the given account. If the wallet does not wrap this particular account,
 // an error is returned to avoid account leakage (even though in theory we may
@@ -138,6 +104,17 @@ func (w *keystoreWallet) SignTx(account accounts.Account, tx *types.Transaction,
 	return w.keystore.SignTx(account, tx, chainID)
 }
 
+// SignHashWithPassphrase implements accounts.Wallet, attempting to sign the
+// given hash with the given account using passphrase as extra authentication.
+func (w *keystoreWallet) SignHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) {
+	// Make sure the requested account is contained within
+	if !w.Contains(account) {
+		return nil, accounts.ErrUnknownAccount
+	}
+	// Account seems valid, request the keystore to sign
+	return w.keystore.SignHashWithPassphrase(account, passphrase, hash)
+}
+
 // SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given
 // transaction with the given account using passphrase as extra authentication.
 func (w *keystoreWallet) SignTxWithPassphrase(account accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {

accounts/keystore/watch.go

@@ -14,7 +14,7 @@
 // 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/>.
 
-// +build darwin,!ios,cgo freebsd linux,!arm64 netbsd solaris
+// +build darwin,!ios freebsd linux,!arm64 netbsd solaris
 
 package keystore
 

accounts/keystore/watch_fallback.go

@@ -14,7 +14,7 @@
 // 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/>.
 
-// +build darwin,!cgo ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris
+// +build ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris
 
 // This is the fallback implementation of directory watching.
 // It is used on unsupported platforms.

accounts/manager.go

@@ -21,22 +21,12 @@ import (
 	"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
@@ -50,7 +40,7 @@ type Manager struct {
 
 // NewManager creates a generic account manager to sign transaction via various
 // supported backends.
-func NewManager(config *Config, backends ...Backend) *Manager {
+func NewManager(backends ...Backend) *Manager {
 	// Retrieve the initial list of wallets from the backends and sort by URL
 	var wallets []Wallet
 	for _, backend := range backends {
@@ -65,7 +55,6 @@ func NewManager(config *Config, backends ...Backend) *Manager {
 	}
 	// Assemble the account manager and return
 	am := &Manager{
-		config:   config,
 		backends: make(map[reflect.Type][]Backend),
 		updaters: subs,
 		updates:  updates,
@@ -88,11 +77,6 @@ func (am *Manager) Close() error {
 	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() {
@@ -141,11 +125,6 @@ func (am *Manager) Wallets() []Wallet {
 	am.lock.RLock()
 	defer am.lock.RUnlock()
 
-	return am.walletsNoLock()
-}
-
-// walletsNoLock returns all registered wallets. Callers must hold am.lock.
-func (am *Manager) walletsNoLock() []Wallet {
 	cpy := make([]Wallet, len(am.wallets))
 	copy(cpy, am.wallets)
 	return cpy
@@ -160,7 +139,7 @@ func (am *Manager) Wallet(url string) (Wallet, error) {
 	if err != nil {
 		return nil, err
 	}
-	for _, wallet := range am.walletsNoLock() {
+	for _, wallet := range am.Wallets() {
 		if wallet.URL() == parsed {
 			return wallet, nil
 		}
@@ -168,20 +147,6 @@ func (am *Manager) Wallet(url string) (Wallet, error) {
 	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.

accounts/scwallet/README.md

@@ -1,106 +0,0 @@
-# Using the smartcard wallet
-
-## Requirements
-
-  * A USB smartcard reader
-  * A keycard that supports the status app
-  * PCSCD version 4.3 running on your system **Only version 4.3 is currently supported**
-
-## Preparing the smartcard
-
-  **WARNING: FOILLOWING THESE INSTRUCTIONS WILL DESTROY THE MASTER KEY ON YOUR CARD. ONLY PROCEED IF NO FUNDS ARE ASSOCIATED WITH THESE ACCOUNTS**
-
-  You can use status' [keycard-cli](https://github.com/status-im/keycard-cli) and you should get _at least_ version 2.1.1 of their [smartcard application](https://github.com/status-im/status-keycard/releases/download/2.2.1/keycard_v2.2.1.cap)
-
-  You also need to make sure that the PCSC daemon is running on your system.
-
-  Then, you can install the application to the card by typing:
-
-  ```
-  keycard install -a keycard_v2.2.1.cap && keycard init
-  ```
-
-  At the end of this process, you will be provided with a PIN, a PUK and a pairing password. Write them down, you'll need them shortly.
-
-  Start `geth` with the `console` command. You will notice the following warning:
-
-  ```
-  WARN [04-09|16:58:38.898] Failed to open wallet                    url=keycard://044def09                          err="smartcard: pairing password needed"
-  ```
-
-  Write down the URL (`keycard://044def09` in this example). Then ask `geth` to open the wallet:
-
-  ```
-  > personal.openWallet("keycard://044def09", "pairing password")
-  ```
-
-  The pairing password has been generated during the card initialization process.
-  
-  The process needs to be repeated once more with the PIN:
-
-  ```
-  > personal.openWallet("keycard://044def09", "PIN number")
-  ```
-  
-  If everything goes well, you should see your new account when typing `personal` on the console:
-
-  ```
-  > personal
-  WARN [04-09|17:02:07.330] Smartcard wallet account derivation failed url=keycard://044def09 err="Unexpected response status Cla=0x80, Ins=0xd1, Sw=0x6985"
-  {
-    listAccounts: [],
-    listWallets: [{
-        status: "Empty, waiting for initialization",
-        url: "keycard://044def09"
-    }],
-    ...
-  }
-  ```
-
-  So the communication with the card is working, but there is no key associated with this wallet. Let's create it:
-
-  ```
-  > personal.initializeWallet("keycard://044def09")
-  "tilt ... impact"
-  ```
-
-  You should get a list of words, this is your seed so write them down. Your wallet should now be initialized:
-
-  ```
-  > personal.listWallets
-  [{
-    accounts: [{
-        address: "0x678b7cd55c61917defb23546a41803c5bfefbc7a",
-        url: "keycard://044d/m/44'/60'/0'/0/0"
-    }],
-    status: "Online",
-    url: "keycard://044def09"
-  }]
-  ```
-
-  You're all set!
-
-## Usage
-
-  1. Start `geth` with the `console` command
-  2. Check the card's URL by checking `personal.listWallets`:
-
-```
-  listWallets: [{
-      status: "Online, can derive public keys",
-      url: "keycard://a4d73015"
-  }]
-```
-
-  3. Open the wallet, you will be prompted for your pairing password, then PIN:
-
-```
-personal.openWallet("keycard://a4d73015")
-```
-
-  4. Check that creation was successful by typing e.g. `personal`. Then use it like a regular wallet.
-
-## Known issues
-
-  * Starting geth with a valid card seems to make firefox crash.
-  * PCSC version 4.4 should work, but is currently untested

accounts/scwallet/apdu.go

@@ -1,87 +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 scwallet
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-)
-
-// commandAPDU represents an application data unit sent to a smartcard.
-type commandAPDU struct {
-	Cla, Ins, P1, P2 uint8  // Class, Instruction, Parameter 1, Parameter 2
-	Data             []byte // Command data
-	Le               uint8  // Command data length
-}
-
-// serialize serializes a command APDU.
-func (ca commandAPDU) serialize() ([]byte, error) {
-	buf := new(bytes.Buffer)
-
-	if err := binary.Write(buf, binary.BigEndian, ca.Cla); err != nil {
-		return nil, err
-	}
-	if err := binary.Write(buf, binary.BigEndian, ca.Ins); err != nil {
-		return nil, err
-	}
-	if err := binary.Write(buf, binary.BigEndian, ca.P1); err != nil {
-		return nil, err
-	}
-	if err := binary.Write(buf, binary.BigEndian, ca.P2); err != nil {
-		return nil, err
-	}
-	if len(ca.Data) > 0 {
-		if err := binary.Write(buf, binary.BigEndian, uint8(len(ca.Data))); err != nil {
-			return nil, err
-		}
-		if err := binary.Write(buf, binary.BigEndian, ca.Data); err != nil {
-			return nil, err
-		}
-	}
-	if err := binary.Write(buf, binary.BigEndian, ca.Le); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-// responseAPDU represents an application data unit received from a smart card.
-type responseAPDU struct {
-	Data     []byte // response data
-	Sw1, Sw2 uint8  // status words 1 and 2
-}
-
-// deserialize deserializes a response APDU.
-func (ra *responseAPDU) deserialize(data []byte) error {
-	if len(data) < 2 {
-		return fmt.Errorf("can not deserialize data: payload too short (%d < 2)", len(data))
-	}
-
-	ra.Data = make([]byte, len(data)-2)
-
-	buf := bytes.NewReader(data)
-	if err := binary.Read(buf, binary.BigEndian, &ra.Data); err != nil {
-		return err
-	}
-	if err := binary.Read(buf, binary.BigEndian, &ra.Sw1); err != nil {
-		return err
-	}
-	if err := binary.Read(buf, binary.BigEndian, &ra.Sw2); err != nil {
-		return err
-	}
-	return nil
-}

accounts/scwallet/hub.go

@@ -1,302 +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/>.
-
-// This package implements support for smartcard-based hardware wallets such as
-// the one written by Status: https://github.com/status-im/hardware-wallet
-//
-// This implementation of smartcard wallets have a different interaction process
-// to other types of hardware wallet. The process works like this:
-//
-// 1. (First use with a given client) Establish a pairing between hardware
-//    wallet and client. This requires a secret value called a 'pairing password'.
-//    You can pair with an unpaired wallet with `personal.openWallet(URI, pairing password)`.
-// 2. (First use only) Initialize the wallet, which generates a keypair, stores
-//    it on the wallet, and returns it so the user can back it up. You can
-//    initialize a wallet with `personal.initializeWallet(URI)`.
-// 3. Connect to the wallet using the pairing information established in step 1.
-//    You can connect to a paired wallet with `personal.openWallet(URI, PIN)`.
-// 4. Interact with the wallet as normal.
-
-package scwallet
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/event"
-	"github.com/ethereum/go-ethereum/log"
-	pcsc "github.com/gballet/go-libpcsclite"
-)
-
-// Scheme is the URI prefix for smartcard wallets.
-const Scheme = "keycard"
-
-// refreshCycle is the maximum time between wallet refreshes (if USB hotplug
-// notifications don't work).
-const refreshCycle = time.Second
-
-// refreshThrottling is the minimum time between wallet refreshes to avoid thrashing.
-const refreshThrottling = 500 * time.Millisecond
-
-// smartcardPairing contains information about a smart card we have paired with
-// or might pair with the hub.
-type smartcardPairing struct {
-	PublicKey    []byte                                     `json:"publicKey"`
-	PairingIndex uint8                                      `json:"pairingIndex"`
-	PairingKey   []byte                                     `json:"pairingKey"`
-	Accounts     map[common.Address]accounts.DerivationPath `json:"accounts"`
-}
-
-// Hub is a accounts.Backend that can find and handle generic PC/SC hardware wallets.
-type Hub struct {
-	scheme string // Protocol scheme prefixing account and wallet URLs.
-
-	context  *pcsc.Client
-	datadir  string
-	pairings map[string]smartcardPairing
-
-	refreshed   time.Time               // Time instance when the list of wallets was last refreshed
-	wallets     map[string]*Wallet      // Mapping from reader names to wallet instances
-	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
-
-	quit chan chan error
-
-	stateLock sync.RWMutex // Protects the internals of the hub from racey access
-}
-
-func (hub *Hub) readPairings() error {
-	hub.pairings = make(map[string]smartcardPairing)
-	pairingFile, err := os.Open(filepath.Join(hub.datadir, "smartcards.json"))
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return err
-	}
-
-	pairingData, err := ioutil.ReadAll(pairingFile)
-	if err != nil {
-		return err
-	}
-	var pairings []smartcardPairing
-	if err := json.Unmarshal(pairingData, &pairings); err != nil {
-		return err
-	}
-
-	for _, pairing := range pairings {
-		hub.pairings[string(pairing.PublicKey)] = pairing
-	}
-	return nil
-}
-
-func (hub *Hub) writePairings() error {
-	pairingFile, err := os.OpenFile(filepath.Join(hub.datadir, "smartcards.json"), os.O_RDWR|os.O_CREATE, 0755)
-	if err != nil {
-		return err
-	}
-	defer pairingFile.Close()
-
-	pairings := make([]smartcardPairing, 0, len(hub.pairings))
-	for _, pairing := range hub.pairings {
-		pairings = append(pairings, pairing)
-	}
-
-	pairingData, err := json.Marshal(pairings)
-	if err != nil {
-		return err
-	}
-
-	if _, err := pairingFile.Write(pairingData); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (hub *Hub) pairing(wallet *Wallet) *smartcardPairing {
-	if pairing, ok := hub.pairings[string(wallet.PublicKey)]; ok {
-		return &pairing
-	}
-	return nil
-}
-
-func (hub *Hub) setPairing(wallet *Wallet, pairing *smartcardPairing) error {
-	if pairing == nil {
-		delete(hub.pairings, string(wallet.PublicKey))
-	} else {
-		hub.pairings[string(wallet.PublicKey)] = *pairing
-	}
-	return hub.writePairings()
-}
-
-// NewHub creates a new hardware wallet manager for smartcards.
-func NewHub(daemonPath string, scheme string, datadir string) (*Hub, error) {
-	context, err := pcsc.EstablishContext(daemonPath, pcsc.ScopeSystem)
-	if err != nil {
-		return nil, err
-	}
-	hub := &Hub{
-		scheme:  scheme,
-		context: context,
-		datadir: datadir,
-		wallets: make(map[string]*Wallet),
-		quit:    make(chan chan error),
-	}
-	if err := hub.readPairings(); err != nil {
-		return nil, err
-	}
-	hub.refreshWallets()
-	return hub, nil
-}
-
-// Wallets implements accounts.Backend, returning all the currently tracked smart
-// cards that appear to be hardware wallets.
-func (hub *Hub) Wallets() []accounts.Wallet {
-	// Make sure the list of wallets is up to date
-	hub.refreshWallets()
-
-	hub.stateLock.RLock()
-	defer hub.stateLock.RUnlock()
-
-	cpy := make([]accounts.Wallet, 0, len(hub.wallets))
-	for _, wallet := range hub.wallets {
-		cpy = append(cpy, wallet)
-	}
-	sort.Sort(accounts.WalletsByURL(cpy))
-	return cpy
-}
-
-// refreshWallets scans the devices attached to the machine and updates the
-// list of wallets based on the found devices.
-func (hub *Hub) refreshWallets() {
-	// Don't scan the USB like crazy it the user fetches wallets in a loop
-	hub.stateLock.RLock()
-	elapsed := time.Since(hub.refreshed)
-	hub.stateLock.RUnlock()
-
-	if elapsed < refreshThrottling {
-		return
-	}
-	// Retrieve all the smart card reader to check for cards
-	readers, err := hub.context.ListReaders()
-	if err != nil {
-		// This is a perverted hack, the scard library returns an error if no card
-		// readers are present instead of simply returning an empty list. We don't
-		// want to fill the user's log with errors, so filter those out.
-		if err.Error() != "scard: Cannot find a smart card reader." {
-			log.Error("Failed to enumerate smart card readers", "err", err)
-			return
-		}
-	}
-	// Transform the current list of wallets into the new one
-	hub.stateLock.Lock()
-
-	events := []accounts.WalletEvent{}
-	seen := make(map[string]struct{})
-
-	for _, reader := range readers {
-		// Mark the reader as present
-		seen[reader] = struct{}{}
-
-		// If we already know about this card, skip to the next reader, otherwise clean up
-		if wallet, ok := hub.wallets[reader]; ok {
-			if err := wallet.ping(); err == nil {
-				continue
-			}
-			wallet.Close()
-			events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
-			delete(hub.wallets, reader)
-		}
-		// New card detected, try to connect to it
-		card, err := hub.context.Connect(reader, pcsc.ShareShared, pcsc.ProtocolAny)
-		if err != nil {
-			log.Debug("Failed to open smart card", "reader", reader, "err", err)
-			continue
-		}
-		wallet := NewWallet(hub, card)
-		if err = wallet.connect(); err != nil {
-			log.Debug("Failed to connect to smart card", "reader", reader, "err", err)
-			card.Disconnect(pcsc.LeaveCard)
-			continue
-		}
-		// Card connected, start tracking in amongs the wallets
-		hub.wallets[reader] = wallet
-		events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletArrived})
-	}
-	// Remove any wallets no longer present
-	for reader, wallet := range hub.wallets {
-		if _, ok := seen[reader]; !ok {
-			wallet.Close()
-			events = append(events, accounts.WalletEvent{Wallet: wallet, Kind: accounts.WalletDropped})
-			delete(hub.wallets, reader)
-		}
-	}
-	hub.refreshed = time.Now()
-	hub.stateLock.Unlock()
-
-	for _, event := range events {
-		hub.updateFeed.Send(event)
-	}
-}
-
-// Subscribe implements accounts.Backend, creating an async subscription to
-// receive notifications on the addition or removal of smart card wallets.
-func (hub *Hub) Subscribe(sink chan<- accounts.WalletEvent) event.Subscription {
-	// We need the mutex to reliably start/stop the update loop
-	hub.stateLock.Lock()
-	defer hub.stateLock.Unlock()
-
-	// Subscribe the caller and track the subscriber count
-	sub := hub.updateScope.Track(hub.updateFeed.Subscribe(sink))
-
-	// Subscribers require an active notification loop, start it
-	if !hub.updating {
-		hub.updating = true
-		go hub.updater()
-	}
-	return sub
-}
-
-// updater is responsible for maintaining an up-to-date list of wallets managed
-// by the smart card hub, and for firing wallet addition/removal events.
-func (hub *Hub) updater() {
-	for {
-		// TODO: Wait for a USB hotplug event (not supported yet) or a refresh timeout
-		// <-hub.changes
-		time.Sleep(refreshCycle)
-
-		// Run the wallet refresher
-		hub.refreshWallets()
-
-		// If all our subscribers left, stop the updater
-		hub.stateLock.Lock()
-		if hub.updateScope.Count() == 0 {
-			hub.updating = false
-			hub.stateLock.Unlock()
-			return
-		}
-		hub.stateLock.Unlock()
-	}
-}

accounts/scwallet/securechannel.go

@@ -1,339 +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 scwallet
-
-import (
-	"bytes"
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/sha256"
-	"crypto/sha512"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/crypto"
-	pcsc "github.com/gballet/go-libpcsclite"
-	"golang.org/x/crypto/pbkdf2"
-	"golang.org/x/text/unicode/norm"
-)
-
-const (
-	maxPayloadSize  = 223
-	pairP1FirstStep = 0
-	pairP1LastStep  = 1
-
-	scSecretLength = 32
-	scBlockSize    = 16
-
-	insOpenSecureChannel    = 0x10
-	insMutuallyAuthenticate = 0x11
-	insPair                 = 0x12
-	insUnpair               = 0x13
-
-	pairingSalt = "Keycard Pairing Password Salt"
-)
-
-// SecureChannelSession enables secure communication with a hardware wallet.
-type SecureChannelSession struct {
-	card          *pcsc.Card // A handle to the smartcard for communication
-	secret        []byte     // A shared secret generated from our ECDSA keys
-	publicKey     []byte     // Our own ephemeral public key
-	PairingKey    []byte     // A permanent shared secret for a pairing, if present
-	sessionEncKey []byte     // The current session encryption key
-	sessionMacKey []byte     // The current session MAC key
-	iv            []byte     // The current IV
-	PairingIndex  uint8      // The pairing index
-}
-
-// NewSecureChannelSession creates a new secure channel for the given card and public key.
-func NewSecureChannelSession(card *pcsc.Card, keyData []byte) (*SecureChannelSession, error) {
-	// Generate an ECDSA keypair for ourselves
-	key, err := crypto.GenerateKey()
-	if err != nil {
-		return nil, err
-	}
-	cardPublic, err := crypto.UnmarshalPubkey(keyData)
-	if err != nil {
-		return nil, fmt.Errorf("could not unmarshal public key from card: %v", err)
-	}
-	secret, _ := key.Curve.ScalarMult(cardPublic.X, cardPublic.Y, key.D.Bytes())
-	return &SecureChannelSession{
-		card:      card,
-		secret:    secret.Bytes(),
-		publicKey: elliptic.Marshal(crypto.S256(), key.PublicKey.X, key.PublicKey.Y),
-	}, nil
-}
-
-// Pair establishes a new pairing with the smartcard.
-func (s *SecureChannelSession) Pair(pairingPassword []byte) error {
-	secretHash := pbkdf2.Key(norm.NFKD.Bytes(pairingPassword), norm.NFKD.Bytes([]byte(pairingSalt)), 50000, 32, sha256.New)
-
-	challenge := make([]byte, 32)
-	if _, err := rand.Read(challenge); err != nil {
-		return err
-	}
-
-	response, err := s.pair(pairP1FirstStep, challenge)
-	if err != nil {
-		return err
-	}
-
-	md := sha256.New()
-	md.Write(secretHash[:])
-	md.Write(challenge)
-
-	expectedCryptogram := md.Sum(nil)
-	cardCryptogram := response.Data[:32]
-	cardChallenge := response.Data[32:64]
-
-	if !bytes.Equal(expectedCryptogram, cardCryptogram) {
-		return fmt.Errorf("invalid card cryptogram %v != %v", expectedCryptogram, cardCryptogram)
-	}
-
-	md.Reset()
-	md.Write(secretHash[:])
-	md.Write(cardChallenge)
-	response, err = s.pair(pairP1LastStep, md.Sum(nil))
-	if err != nil {
-		return err
-	}
-
-	md.Reset()
-	md.Write(secretHash[:])
-	md.Write(response.Data[1:])
-	s.PairingKey = md.Sum(nil)
-	s.PairingIndex = response.Data[0]
-
-	return nil
-}
-
-// Unpair disestablishes an existing pairing.
-func (s *SecureChannelSession) Unpair() error {
-	if s.PairingKey == nil {
-		return fmt.Errorf("cannot unpair: not paired")
-	}
-
-	_, err := s.transmitEncrypted(claSCWallet, insUnpair, s.PairingIndex, 0, []byte{})
-	if err != nil {
-		return err
-	}
-	s.PairingKey = nil
-	// Close channel
-	s.iv = nil
-	return nil
-}
-
-// Open initializes the secure channel.
-func (s *SecureChannelSession) Open() error {
-	if s.iv != nil {
-		return fmt.Errorf("session already opened")
-	}
-
-	response, err := s.open()
-	if err != nil {
-		return err
-	}
-
-	// Generate the encryption/mac key by hashing our shared secret,
-	// pairing key, and the first bytes returned from the Open APDU.
-	md := sha512.New()
-	md.Write(s.secret)
-	md.Write(s.PairingKey)
-	md.Write(response.Data[:scSecretLength])
-	keyData := md.Sum(nil)
-	s.sessionEncKey = keyData[:scSecretLength]
-	s.sessionMacKey = keyData[scSecretLength : scSecretLength*2]
-
-	// The IV is the last bytes returned from the Open APDU.
-	s.iv = response.Data[scSecretLength:]
-
-	return s.mutuallyAuthenticate()
-}
-
-// mutuallyAuthenticate is an internal method to authenticate both ends of the
-// connection.
-func (s *SecureChannelSession) mutuallyAuthenticate() error {
-	data := make([]byte, scSecretLength)
-	if _, err := rand.Read(data); err != nil {
-		return err
-	}
-
-	response, err := s.transmitEncrypted(claSCWallet, insMutuallyAuthenticate, 0, 0, data)
-	if err != nil {
-		return err
-	}
-	if response.Sw1 != 0x90 || response.Sw2 != 0x00 {
-		return fmt.Errorf("got unexpected response from MUTUALLY_AUTHENTICATE: 0x%x%x", response.Sw1, response.Sw2)
-	}
-
-	if len(response.Data) != scSecretLength {
-		return fmt.Errorf("response from MUTUALLY_AUTHENTICATE was %d bytes, expected %d", len(response.Data), scSecretLength)
-	}
-
-	return nil
-}
-
-// open is an internal method that sends an open APDU.
-func (s *SecureChannelSession) open() (*responseAPDU, error) {
-	return transmit(s.card, &commandAPDU{
-		Cla:  claSCWallet,
-		Ins:  insOpenSecureChannel,
-		P1:   s.PairingIndex,
-		P2:   0,
-		Data: s.publicKey,
-		Le:   0,
-	})
-}
-
-// pair is an internal method that sends a pair APDU.
-func (s *SecureChannelSession) pair(p1 uint8, data []byte) (*responseAPDU, error) {
-	return transmit(s.card, &commandAPDU{
-		Cla:  claSCWallet,
-		Ins:  insPair,
-		P1:   p1,
-		P2:   0,
-		Data: data,
-		Le:   0,
-	})
-}
-
-// transmitEncrypted sends an encrypted message, and decrypts and returns the response.
-func (s *SecureChannelSession) transmitEncrypted(cla, ins, p1, p2 byte, data []byte) (*responseAPDU, error) {
-	if s.iv == nil {
-		return nil, fmt.Errorf("channel not open")
-	}
-
-	data, err := s.encryptAPDU(data)
-	if err != nil {
-		return nil, err
-	}
-	meta := [16]byte{cla, ins, p1, p2, byte(len(data) + scBlockSize)}
-	if err = s.updateIV(meta[:], data); err != nil {
-		return nil, err
-	}
-
-	fulldata := make([]byte, len(s.iv)+len(data))
-	copy(fulldata, s.iv)
-	copy(fulldata[len(s.iv):], data)
-
-	response, err := transmit(s.card, &commandAPDU{
-		Cla:  cla,
-		Ins:  ins,
-		P1:   p1,
-		P2:   p2,
-		Data: fulldata,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	rmeta := [16]byte{byte(len(response.Data))}
-	rmac := response.Data[:len(s.iv)]
-	rdata := response.Data[len(s.iv):]
-	plainData, err := s.decryptAPDU(rdata)
-	if err != nil {
-		return nil, err
-	}
-
-	if err = s.updateIV(rmeta[:], rdata); err != nil {
-		return nil, err
-	}
-	if !bytes.Equal(s.iv, rmac) {
-		return nil, fmt.Errorf("invalid MAC in response")
-	}
-
-	rapdu := &responseAPDU{}
-	rapdu.deserialize(plainData)
-
-	if rapdu.Sw1 != sw1Ok {
-		return nil, fmt.Errorf("unexpected response status Cla=0x%x, Ins=0x%x, Sw=0x%x%x", cla, ins, rapdu.Sw1, rapdu.Sw2)
-	}
-
-	return rapdu, nil
-}
-
-// encryptAPDU is an internal method that serializes and encrypts an APDU.
-func (s *SecureChannelSession) encryptAPDU(data []byte) ([]byte, error) {
-	if len(data) > maxPayloadSize {
-		return nil, fmt.Errorf("payload of %d bytes exceeds maximum of %d", len(data), maxPayloadSize)
-	}
-	data = pad(data, 0x80)
-
-	ret := make([]byte, len(data))
-
-	a, err := aes.NewCipher(s.sessionEncKey)
-	if err != nil {
-		return nil, err
-	}
-	crypter := cipher.NewCBCEncrypter(a, s.iv)
-	crypter.CryptBlocks(ret, data)
-	return ret, nil
-}
-
-// pad applies message padding to a 16 byte boundary.
-func pad(data []byte, terminator byte) []byte {
-	padded := make([]byte, (len(data)/16+1)*16)
-	copy(padded, data)
-	padded[len(data)] = terminator
-	return padded
-}
-
-// decryptAPDU is an internal method that decrypts and deserializes an APDU.
-func (s *SecureChannelSession) decryptAPDU(data []byte) ([]byte, error) {
-	a, err := aes.NewCipher(s.sessionEncKey)
-	if err != nil {
-		return nil, err
-	}
-
-	ret := make([]byte, len(data))
-
-	crypter := cipher.NewCBCDecrypter(a, s.iv)
-	crypter.CryptBlocks(ret, data)
-	return unpad(ret, 0x80)
-}
-
-// unpad strips padding from a message.
-func unpad(data []byte, terminator byte) ([]byte, error) {
-	for i := 1; i <= 16; i++ {
-		switch data[len(data)-i] {
-		case 0:
-			continue
-		case terminator:
-			return data[:len(data)-i], nil
-		default:
-			return nil, fmt.Errorf("expected end of padding, got %d", data[len(data)-i])
-		}
-	}
-	return nil, fmt.Errorf("expected end of padding, got 0")
-}
-
-// updateIV is an internal method that updates the initialization vector after
-// each message exchanged.
-func (s *SecureChannelSession) updateIV(meta, data []byte) error {
-	data = pad(data, 0)
-	a, err := aes.NewCipher(s.sessionMacKey)
-	if err != nil {
-		return err
-	}
-	crypter := cipher.NewCBCEncrypter(a, make([]byte, 16))
-	crypter.CryptBlocks(meta, meta)
-	crypter.CryptBlocks(data, data)
-	// The first 16 bytes of the last block is the MAC
-	s.iv = data[len(data)-32 : len(data)-16]
-	return nil
-}

accounts/sort.go

@@ -1,31 +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
-
-// AccountsByURL implements sort.Interface for []Account based on the URL field.
-type AccountsByURL []Account
-
-func (a AccountsByURL) Len() int           { return len(a) }
-func (a AccountsByURL) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a AccountsByURL) Less(i, j int) bool { return a[i].URL.Cmp(a[j].URL) < 0 }
-
-// WalletsByURL implements sort.Interface for []Wallet based on the URL field.
-type WalletsByURL []Wallet
-
-func (w WalletsByURL) Len() int           { return len(w) }
-func (w WalletsByURL) Swap(i, j int)      { w[i], w[j] = w[j], w[i] }
-func (w WalletsByURL) Less(i, j int) bool { return w[i].URL().Cmp(w[j].URL()) < 0 }

accounts/url_test.go

@@ -1,4 +1,4 @@
-// Copyright 2018 The go-ethereum Authors
+// 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

accounts/usbwallet/hub.go

@@ -20,13 +20,12 @@ import (
 	"errors"
 	"runtime"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/karalabe/usb"
+	"github.com/karalabe/hid"
 )
 
 // LedgerScheme is the protocol scheme prefixing account and wallet URLs.
@@ -65,41 +64,21 @@ type Hub struct {
 	// TODO(karalabe): remove if hotplug lands on Windows
 	commsPend int        // Number of operations blocking enumeration
 	commsLock sync.Mutex // Lock protecting the pending counter and enumeration
-	enumFails uint32     // Number of times enumeration has failed
 }
 
 // NewLedgerHub creates a new hardware wallet manager for Ledger devices.
 func NewLedgerHub() (*Hub, error) {
-	return newHub(LedgerScheme, 0x2c97, []uint16{
-		// Original product IDs
-		0x0000, /* Ledger Blue */
-		0x0001, /* Ledger Nano S */
-		0x0004, /* Ledger Nano X */
-
-		// Upcoming product IDs: https://www.ledger.com/2019/05/17/windows-10-update-sunsetting-u2f-tunnel-transport-for-ledger-devices/
-		0x0015, /* HID + U2F + WebUSB Ledger Blue */
-		0x1015, /* HID + U2F + WebUSB Ledger Nano S */
-		0x4015, /* HID + U2F + WebUSB Ledger Nano X */
-		0x0011, /* HID + WebUSB Ledger Blue */
-		0x1011, /* HID + WebUSB Ledger Nano S */
-		0x4011, /* HID + WebUSB Ledger Nano X */
-	}, 0xffa0, 0, newLedgerDriver)
+	return newHub(LedgerScheme, 0x2c97, []uint16{0x0000 /* Ledger Blue */, 0x0001 /* Ledger Nano S */}, 0xffa0, 0, newLedgerDriver)
 }
 
-// NewTrezorHubWithHID creates a new hardware wallet manager for Trezor devices.
-func NewTrezorHubWithHID() (*Hub, error) {
-	return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor HID */}, 0xff00, 0, newTrezorDriver)
-}
-
-// NewTrezorHubWithWebUSB creates a new hardware wallet manager for Trezor devices with
-// firmware version > 1.8.0
-func NewTrezorHubWithWebUSB() (*Hub, error) {
-	return newHub(TrezorScheme, 0x1209, []uint16{0x53c1 /* Trezor WebUSB */}, 0xffff /* No usage id on webusb, don't match unset (0) */, 0, newTrezorDriver)
+// NewTrezorHub creates a new hardware wallet manager for Trezor devices.
+func NewTrezorHub() (*Hub, error) {
+	return newHub(TrezorScheme, 0x534c, []uint16{0x0001 /* Trezor 1 */}, 0xff00, 0, newTrezorDriver)
 }
 
 // newHub creates a new hardware wallet manager for generic USB devices.
 func newHub(scheme string, vendorID uint16, productIDs []uint16, usageID uint16, endpointID int, makeDriver func(log.Logger) driver) (*Hub, error) {
-	if !usb.Supported() {
+	if !hid.Supported() {
 		return nil, errors.New("unsupported platform")
 	}
 	hub := &Hub{
@@ -140,12 +119,8 @@ func (hub *Hub) refreshWallets() {
 	if elapsed < refreshThrottling {
 		return
 	}
-	// If USB enumeration is continually failing, don't keep trying indefinitely
-	if atomic.LoadUint32(&hub.enumFails) > 2 {
-		return
-	}
 	// Retrieve the current list of USB wallet devices
-	var devices []usb.DeviceInfo
+	var devices []hid.DeviceInfo
 
 	if runtime.GOOS == "linux" {
 		// hidapi on Linux opens the device during enumeration to retrieve some infos,
@@ -160,22 +135,8 @@ func (hub *Hub) refreshWallets() {
 			return
 		}
 	}
-	infos, err := usb.Enumerate(hub.vendorID, 0)
-	if err != nil {
-		failcount := atomic.AddUint32(&hub.enumFails, 1)
-		if runtime.GOOS == "linux" {
-			// See rationale before the enumeration why this is needed and only on Linux.
-			hub.commsLock.Unlock()
-		}
-		log.Error("Failed to enumerate USB devices", "hub", hub.scheme,
-			"vendor", hub.vendorID, "failcount", failcount, "err", err)
-		return
-	}
-	atomic.StoreUint32(&hub.enumFails, 0)
-
-	for _, info := range infos {
+	for _, info := range hid.Enumerate(hub.vendorID, 0) {
 		for _, id := range hub.productIDs {
-			// Windows and Macos use UsageID matching, Linux uses Interface matching
 			if info.ProductID == id && (info.UsagePage == hub.usageID || info.Interface == hub.endpointID) {
 				devices = append(devices, info)
 				break
@@ -189,10 +150,8 @@ func (hub *Hub) refreshWallets() {
 	// Transform the current list of wallets into the new one
 	hub.stateLock.Lock()
 
-	var (
-		wallets = make([]accounts.Wallet, 0, len(devices))
-		events  []accounts.WalletEvent
-	)
+	wallets := make([]accounts.Wallet, 0, len(devices))
+	events := []accounts.WalletEvent{}
 
 	for _, device := range devices {
 		url := accounts.URL{Scheme: hub.scheme, Path: device.Path}

accounts/usbwallet/internal/trezor/messages.proto

@@ -0,0 +1,905 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/messages.proto
+// dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b.
+
+syntax = "proto2";
+
+/**
+ * Messages for TREZOR communication
+ */
+
+// Sugar for easier handling in Java
+option java_package = "com.satoshilabs.trezor.lib.protobuf";
+option java_outer_classname = "TrezorMessage";
+
+import "types.proto";
+
+/**
+ * Mapping between Trezor wire identifier (uint) and a protobuf message
+ */
+enum MessageType {
+	MessageType_Initialize = 0 [(wire_in) = 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_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_GetEntropy = 9 [(wire_in) = true];
+	MessageType_Entropy = 10 [(wire_out) = true];
+	MessageType_GetPublicKey = 11 [(wire_in) = true];
+	MessageType_PublicKey = 12 [(wire_out) = true];
+	MessageType_LoadDevice = 13 [(wire_in) = true];
+	MessageType_ResetDevice = 14 [(wire_in) = true];
+	MessageType_SignTx = 15 [(wire_in) = true];
+	MessageType_SimpleSignTx = 16 [(wire_in) = true, deprecated = true];
+	MessageType_Features = 17 [(wire_out) = true];
+	MessageType_PinMatrixRequest = 18 [(wire_out) = true];
+	MessageType_PinMatrixAck = 19 [(wire_in) = true, (wire_tiny) = true];
+	MessageType_Cancel = 20 [(wire_in) = true];
+	MessageType_TxRequest = 21 [(wire_out) = true];
+	MessageType_TxAck = 22 [(wire_in) = true];
+	MessageType_CipherKeyValue = 23 [(wire_in) = 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];
+	MessageType_ApplyFlags = 28 [(wire_in) = true];
+	MessageType_GetAddress = 29 [(wire_in) = true];
+	MessageType_Address = 30 [(wire_out) = true];
+	MessageType_SelfTest = 32 [(wire_in) = true, (wire_bootloader) = true];
+	MessageType_BackupDevice = 34 [(wire_in) = true];
+	MessageType_EntropyRequest = 35 [(wire_out) = true];
+	MessageType_EntropyAck = 36 [(wire_in) = true];
+	MessageType_SignMessage = 38 [(wire_in) = true];
+	MessageType_VerifyMessage = 39 [(wire_in) = true];
+	MessageType_MessageSignature = 40 [(wire_out) = true];
+	MessageType_PassphraseRequest = 41 [(wire_out) = true];
+	MessageType_PassphraseAck = 42 [(wire_in) = true, (wire_tiny) = true];
+	MessageType_EstimateTxSize = 43 [(wire_in) = true, deprecated = true];
+	MessageType_TxSize = 44 [(wire_out) = true, deprecated = true];
+	MessageType_RecoveryDevice = 45 [(wire_in) = true];
+	MessageType_WordRequest = 46 [(wire_out) = true];
+	MessageType_WordAck = 47 [(wire_in) = true];
+	MessageType_CipheredKeyValue = 48 [(wire_out) = true];
+	MessageType_EncryptMessage = 49 [(wire_in) = true, deprecated = true];
+	MessageType_EncryptedMessage = 50 [(wire_out) = true, deprecated = true];
+	MessageType_DecryptMessage = 51 [(wire_in) = true, deprecated = true];
+	MessageType_DecryptedMessage = 52 [(wire_out) = true, deprecated = true];
+	MessageType_SignIdentity = 53 [(wire_in) = true];
+	MessageType_SignedIdentity = 54 [(wire_out) = true];
+	MessageType_GetFeatures = 55 [(wire_in) = 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_GetECDHSessionKey = 61 [(wire_in) = true];
+	MessageType_ECDHSessionKey = 62 [(wire_out) = true];
+	MessageType_SetU2FCounter = 63 [(wire_in) = true];
+	MessageType_EthereumSignMessage = 64 [(wire_in) = true];
+	MessageType_EthereumVerifyMessage = 65 [(wire_in) = true];
+	MessageType_EthereumMessageSignature = 66 [(wire_out) = true];
+	MessageType_DebugLinkDecision = 100 [(wire_debug_in) = true, (wire_tiny) = true];
+	MessageType_DebugLinkGetState = 101 [(wire_debug_in) = 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];
+}
+
+////////////////////
+// Basic messages //
+////////////////////
+
+/**
+ * Request: Reset device to default state and ask for device details
+ * @next Features
+ */
+message Initialize {
+}
+
+/**
+ * Request: Ask for device details (no device reset)
+ * @next Features
+ */
+message GetFeatures {
+}
+
+/**
+ * Response: Reports various information about the device
+ * @prev Initialize
+ * @prev GetFeatures
+ */
+message Features {
+	optional string vendor = 1;			// name of the manufacturer, e.g. "bitcointrezor.com"
+	optional uint32 major_version = 2;		// major version of the device, e.g. 1
+	optional uint32 minor_version = 3;		// minor version of the device, e.g. 0
+	optional uint32 patch_version = 4;		// patch version of the device, 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
+	repeated CoinType coins = 11;			// supported coins
+	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)
+}
+
+/**
+ * Request: clear session (removes cached PIN, passphrase, etc).
+ * @next Success
+ */
+message ClearSession {
+}
+
+/**
+ * Request: change language and/or label of the device
+ * @next Success
+ * @next Failure
+ * @next ButtonRequest
+ * @next PinMatrixRequest
+ */
+message ApplySettings {
+	optional string language = 1;
+	optional string label = 2;
+	optional bool use_passphrase = 3;
+	optional bytes homescreen = 4;
+}
+
+/**
+ * Request: set flags of the device
+ * @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
+ * @next ButtonRequest
+ * @next PinMatrixRequest
+ */
+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
+ * @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
+}
+
+/**
+ * Response: Success of the previous request
+ */
+message Success {
+	optional string message = 1;	// human readable description of action or request-specific payload
+}
+
+/**
+ * Response: Failure of the previous request
+ */
+message Failure {
+	optional FailureType code = 1;	// computer-readable definition of the error state
+	optional string message = 2;	// human-readable message of the error state
+}
+
+/**
+ * Response: Device is waiting for HW button press.
+ * @next ButtonAck
+ * @next Cancel
+ */
+message ButtonRequest {
+	optional ButtonRequestType code = 1;
+	optional string data = 2;
+}
+
+/**
+ * Request: Computer agrees to wait for HW button press
+ * @prev ButtonRequest
+ */
+message ButtonAck {
+}
+
+/**
+ * Response: Device is asking computer to show PIN matrix and awaits PIN encoded using this matrix scheme
+ * @next PinMatrixAck
+ * @next Cancel
+ */
+message PinMatrixRequest {
+	optional PinMatrixRequestType type = 1;
+}
+
+/**
+ * Request: Computer responds with encoded PIN
+ * @prev PinMatrixRequest
+ */
+message PinMatrixAck {
+	required string pin = 1;		// matrix encoded PIN entered by user
+}
+
+/**
+ * Request: Abort last operation that required user interaction
+ * @prev ButtonRequest
+ * @prev PinMatrixRequest
+ * @prev PassphraseRequest
+ */
+message Cancel {
+}
+
+/**
+ * Response: Device awaits encryption passphrase
+ * @next PassphraseAck
+ * @next Cancel
+ */
+message PassphraseRequest {
+}
+
+/**
+ * Request: Send passphrase back
+ * @prev PassphraseRequest
+ */
+message PassphraseAck {
+	required string passphrase = 1;
+}
+
+/**
+ * Request: Request a sample of random data generated by hardware RNG. May be used for testing.
+ * @next ButtonRequest
+ * @next Entropy
+ * @next Failure
+ */
+message GetEntropy {
+	required uint32 size = 1;		// size of requested entropy
+}
+
+/**
+ * Response: Reply with random data generated by internal RNG
+ * @prev GetEntropy
+ */
+message Entropy {
+	required bytes entropy = 1;		// stream of random generated bytes
+}
+
+/**
+ * Request: Ask device for public key corresponding to address_n path
+ * @next PassphraseRequest
+ * @next PublicKey
+ * @next Failure
+ */
+message GetPublicKey {
+	repeated uint32 address_n = 1;		// BIP-32 path to derive the key from master node
+	optional string ecdsa_curve_name = 2;	// ECDSA curve name to use
+	optional bool show_display = 3;		// optionally show on display before sending the result
+	optional string coin_name = 4 [default='Bitcoin'];
+}
+
+/**
+ * Response: Contains public key derived from device private seed
+ * @prev GetPublicKey
+ */
+message PublicKey {
+	required HDNodeType node = 1;		// BIP32 public node
+	optional string xpub = 2;		// serialized form of public node
+}
+
+/**
+ * Request: Ask device for address corresponding to address_n path
+ * @next PassphraseRequest
+ * @next Address
+ * @next Failure
+ */
+message GetAddress {
+	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
+	optional string coin_name = 2 [default='Bitcoin'];
+	optional bool show_display = 3			;			// optionally show on display before sending the result
+	optional MultisigRedeemScriptType multisig = 4;				// filled if we are showing a multisig address
+	optional InputScriptType script_type = 5 [default=SPENDADDRESS];	// used to distinguish between various address formats (non-segwit, segwit, etc.)
+}
+
+/**
+ * Request: Ask device for Ethereum address corresponding to address_n path
+ * @next PassphraseRequest
+ * @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 address derived from device private seed
+ * @prev GetAddress
+ */
+message Address {
+	required string address = 1;		// Coin address in Base58 encoding
+}
+
+/**
+ * Response: Contains an Ethereum address derived from device private seed
+ * @prev EthereumGetAddress
+ */
+message EthereumAddress {
+	required bytes address = 1;		// Coin address as an Ethereum 160 bit hash
+}
+
+/**
+ * Request: Request device to wipe all sensitive data and settings
+ * @next ButtonRequest
+ */
+message WipeDevice {
+}
+
+/**
+ * Request: Load seed and related internal settings from the computer
+ * @next ButtonRequest
+ * @next Success
+ * @next Failure
+ */
+message LoadDevice {
+	optional string mnemonic = 1;				// seed encoded as BIP-39 mnemonic (12, 18 or 24 words)
+	optional 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
+ * @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
+}
+
+/**
+ * Request: Perform backup of the device seed if not backed up using ResetDevice
+ * @next ButtonRequest
+ */
+message BackupDevice {
+}
+
+/**
+ * Response: Ask for additional entropy from host computer
+ * @prev ResetDevice
+ * @next EntropyAck
+ */
+message EntropyRequest {
+}
+
+/**
+ * Request: Provide additional entropy for seed generation function
+ * @prev EntropyRequest
+ * @next ButtonRequest
+ */
+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.
+ * @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 uint32 type = 8;				// supported recovery type (see RecoveryType)
+	optional uint32 u2f_counter = 9;			// U2F counter
+	optional bool dry_run = 10;				// perform dry-run recovery workflow (for safe mnemonic validation)
+}
+
+/**
+ * Response: Device is waiting for user to enter word of the mnemonic
+ * Its position is shown only on device's internal display.
+ * @prev RecoveryDevice
+ * @prev WordAck
+ */
+message WordRequest {
+	optional WordRequestType type = 1;
+}
+
+/**
+ * Request: Computer replies with word from the mnemonic
+ * @prev WordRequest
+ * @next WordRequest
+ * @next Success
+ * @next Failure
+ */
+message WordAck {
+	required string word = 1;				// one word of mnemonic on asked position
+}
+
+//////////////////////////////
+// Message signing messages //
+//////////////////////////////
+
+/**
+ * Request: Ask device to sign message
+ * @next MessageSignature
+ * @next Failure
+ */
+message SignMessage {
+	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
+	required bytes message = 2;						// message to be signed
+	optional string coin_name = 3 [default='Bitcoin'];			// coin to use for signing
+	optional InputScriptType script_type = 4 [default=SPENDADDRESS];	// used to distinguish between various address formats (non-segwit, segwit, etc.)
+}
+
+/**
+ * Request: Ask device to verify message
+ * @next Success
+ * @next Failure
+ */
+message VerifyMessage {
+	optional string address = 1;				// address to verify
+	optional bytes signature = 2;				// signature to verify
+	optional bytes message = 3;				// message to verify
+	optional string coin_name = 4 [default='Bitcoin'];	// coin to use for verifying
+}
+
+/**
+ * Response: Signed message
+ * @prev SignMessage
+ */
+message MessageSignature {
+	optional string address = 1;				// address used to sign the message
+	optional bytes signature = 2;				// signature of the message
+}
+
+///////////////////////////
+// Encryption/decryption //
+///////////////////////////
+
+/**
+ * Request: Ask device to encrypt message
+ * @next EncryptedMessage
+ * @next Failure
+ */
+message EncryptMessage {
+	optional bytes pubkey = 1;				// public key
+	optional bytes message = 2;				// message to encrypt
+	optional bool display_only = 3;				// show just on display? (don't send back via wire)
+	repeated uint32 address_n = 4;				// BIP-32 path to derive the signing key from master node
+	optional string coin_name = 5 [default='Bitcoin'];	// coin to use for signing
+}
+
+/**
+ * Response: Encrypted message
+ * @prev EncryptMessage
+ */
+message EncryptedMessage {
+	optional bytes nonce = 1;				// nonce used during encryption
+	optional bytes message = 2;				// encrypted message
+	optional bytes hmac = 3;				// message hmac
+}
+
+/**
+ * Request: Ask device to decrypt message
+ * @next Success
+ * @next Failure
+ */
+message DecryptMessage {
+	repeated uint32 address_n = 1;				// BIP-32 path to derive the decryption key from master node
+	optional bytes nonce = 2;				// nonce used during encryption
+	optional bytes message = 3;				// message to decrypt
+	optional bytes hmac = 4;				// message hmac
+}
+
+/**
+ * Response: Decrypted message
+ * @prev DecryptedMessage
+ */
+message DecryptedMessage {
+	optional bytes message = 1;				// decrypted message
+	optional string address = 2;				// address used to sign the message (if used)
+}
+
+/**
+ * Request: Ask device to encrypt or decrypt value of given key
+ * @next CipheredKeyValue
+ * @next Failure
+ */
+message CipherKeyValue {
+	repeated uint32 address_n = 1;		// BIP-32 path to derive the key from master node
+	optional string key = 2;		// key component of key:value
+	optional bytes value = 3;		// value component of key:value
+	optional bool encrypt = 4;		// are we encrypting (True) or decrypting (False)?
+	optional bool ask_on_encrypt = 5;	// should we ask on encrypt operation?
+	optional bool ask_on_decrypt = 6;	// should we ask on decrypt operation?
+	optional bytes iv = 7;			// initialization vector (will be computed if not set)
+}
+
+/**
+ * Response: Return ciphered/deciphered value
+ * @prev CipherKeyValue
+ */
+message CipheredKeyValue {
+	optional bytes value = 1;		// ciphered/deciphered value
+}
+
+//////////////////////////////////
+// Transaction signing messages //
+//////////////////////////////////
+
+/**
+ * Request: Estimated size of the transaction
+ * This behaves exactly like SignTx, which means that it can ask using TxRequest
+ * This call is non-blocking (except possible PassphraseRequest to unlock the seed)
+ * @next TxSize
+ * @next Failure
+ */
+message EstimateTxSize {
+	required uint32 outputs_count = 1;			// number of transaction outputs
+	required uint32 inputs_count = 2;			// number of transaction inputs
+	optional string coin_name = 3 [default='Bitcoin'];	// coin to use
+}
+
+/**
+ * Response: Estimated size of the transaction
+ * @prev EstimateTxSize
+ */
+message TxSize {
+	optional uint32 tx_size = 1;				// estimated size of transaction in bytes
+}
+
+/**
+ * Request: Ask device to sign transaction
+ * @next PassphraseRequest
+ * @next PinMatrixRequest
+ * @next TxRequest
+ * @next Failure
+ */
+message SignTx {
+	required uint32 outputs_count = 1;			// number of transaction outputs
+	required uint32 inputs_count = 2;			// number of transaction inputs
+	optional string coin_name = 3 [default='Bitcoin'];	// coin to use
+	optional uint32 version = 4 [default=1];		// transaction version
+	optional uint32 lock_time = 5 [default=0];		// transaction lock_time
+}
+
+/**
+ * Request: Simplified transaction signing
+ * This method doesn't support streaming, so there are hardware limits in number of inputs and outputs.
+ * In case of success, the result is returned using TxRequest message.
+ * @next PassphraseRequest
+ * @next PinMatrixRequest
+ * @next TxRequest
+ * @next Failure
+ */
+message SimpleSignTx {
+	repeated TxInputType inputs = 1;			// transaction inputs
+	repeated TxOutputType outputs = 2;			// transaction outputs
+	repeated TransactionType transactions = 3;		// transactions whose outputs are used to build current inputs
+	optional string coin_name = 4 [default='Bitcoin'];	// coin to use
+	optional uint32 version = 5 [default=1];		// transaction version
+	optional uint32 lock_time = 6 [default=0];		// transaction lock_time
+}
+
+/**
+ * Response: Device asks for information for signing transaction or returns the last result
+ * If request_index is set, device awaits TxAck message (with fields filled in according to request_type)
+ * If signature_index is set, 'signature' contains signed input of signature_index's input
+ * @prev SignTx
+ * @prev SimpleSignTx
+ * @prev TxAck
+ */
+message TxRequest {
+	optional RequestType request_type = 1;			// what should be filled in TxAck message?
+	optional TxRequestDetailsType details = 2;		// request for tx details
+	optional TxRequestSerializedType serialized = 3;	// serialized data and request for next
+}
+
+/**
+ * Request: Reported transaction data
+ * @prev TxRequest
+ * @next TxRequest
+ */
+message TxAck {
+	optional TransactionType tx = 1;
+}
+
+/**
+ * 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.
+ * @next PassphraseRequest
+ * @next PinMatrixRequest
+ * @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 to = 5;				// 160 bit address hash
+	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
+}
+
+/**
+ * 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.
+ * @prev EthereumSignTx
+ * @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.
+ * @prev EthereumTxRequest
+ * @next EthereumTxRequest
+ */
+message EthereumTxAck {
+	optional bytes data_chunk = 1;			// Bytes from transaction payload (<= 1024 bytes)
+}
+
+////////////////////////////////////////
+// Ethereum: Message signing messages //
+////////////////////////////////////////
+
+/**
+ * Request: Ask device to sign message
+ * @next EthereumMessageSignature
+ * @next Failure
+ */
+message EthereumSignMessage {
+	repeated uint32 address_n = 1;				// BIP-32 path to derive the key from master node
+	required bytes message = 2;				// message to be signed
+}
+
+/**
+ * Request: Ask device to verify message
+ * @next Success
+ * @next Failure
+ */
+message EthereumVerifyMessage {
+	optional bytes address = 1;				// address to verify
+	optional bytes signature = 2;				// signature to verify
+	optional bytes message = 3;				// message to verify
+}
+
+/**
+ * Response: Signed message
+ * @prev EthereumSignMessage
+ */
+message EthereumMessageSignature {
+	optional bytes address = 1;				// address used to sign the message
+	optional bytes signature = 2;				// signature of the message
+}
+
+///////////////////////
+// Identity messages //
+///////////////////////
+
+/**
+ * Request: Ask device to sign identity
+ * @next SignedIdentity
+ * @next Failure
+ */
+message SignIdentity {
+	optional IdentityType identity = 1;		// identity
+	optional bytes challenge_hidden = 2;		// non-visible challenge
+	optional string challenge_visual = 3;		// challenge shown on display (e.g. date+time)
+	optional string ecdsa_curve_name = 4;		// ECDSA curve name to use
+}
+
+/**
+ * Response: Device provides signed identity
+ * @prev SignIdentity
+ */
+message SignedIdentity {
+	optional string address = 1;			// identity address
+	optional bytes public_key = 2;			// identity public key
+	optional bytes signature = 3;			// signature of the identity data
+}
+
+///////////////////
+// ECDH messages //
+///////////////////
+
+/**
+ * Request: Ask device to generate ECDH session key
+ * @next ECDHSessionKey
+ * @next Failure
+ */
+message GetECDHSessionKey {
+	optional IdentityType identity = 1;		// identity
+	optional bytes peer_public_key = 2;		// peer's public key
+	optional string ecdsa_curve_name = 3;		// ECDSA curve name to use
+}
+
+/**
+ * Response: Device provides ECDH session key
+ * @prev GetECDHSessionKey
+ */
+message ECDHSessionKey {
+	optional bytes session_key = 1;			// ECDH session key
+}
+
+///////////////////
+// U2F messages //
+///////////////////
+
+/**
+ * Request: Set U2F counter
+ * @next Success
+ */
+message SetU2FCounter {
+	optional uint32 u2f_counter = 1;		// counter
+}
+
+/////////////////////////
+// Bootloader messages //
+/////////////////////////
+
+/**
+ * Request: Ask device to erase its firmware (so it can be replaced via FirmwareUpload)
+ * @next Success
+ * @next FirmwareRequest
+ * @next Failure
+ */
+message FirmwareErase {
+	optional uint32 length = 1;			// length of new firmware
+}
+
+/**
+ * Response: Ask for firmware chunk
+ * @next FirmwareUpload
+ */
+message FirmwareRequest {
+	optional uint32 offset = 1;			// offset of requested firmware chunk
+	optional uint32 length = 2;			// length of requested firmware chunk
+}
+
+/**
+ * Request: Send firmware in binary form to the device
+ * @next Success
+ * @next Failure
+ */
+message FirmwareUpload {
+	required bytes payload = 1;			// firmware to be loaded into device
+	optional bytes hash = 2;			// hash of the payload
+}
+
+
+/**
+ * Request: Perform a device self-test
+ * @next Success
+ * @next Failure
+ */
+message SelfTest {
+	optional bytes payload = 1;			// payload to be used in self-test
+}
+
+/////////////////////////////////////////////////////////////
+// Debug messages (only available if DebugLink is enabled) //
+/////////////////////////////////////////////////////////////
+
+/**
+ * Request: "Press" the button on the device
+ * @next Success
+ */
+message DebugLinkDecision {
+	required bool yes_no = 1;			// true for "Confirm", false for "Cancel"
+}
+
+/**
+ * Request: Computer asks for device state
+ * @next DebugLinkState
+ */
+message DebugLinkGetState {
+}
+
+/**
+ * Response: Device current state
+ * @prev DebugLinkGetState
+ */
+message DebugLinkState {
+	optional bytes layout = 1;			// raw buffer of display
+	optional string pin = 2;			// current PIN, blank if PIN is not set/enabled
+	optional string matrix = 3;			// current PIN matrix
+	optional string mnemonic = 4;			// current BIP-39 mnemonic
+	optional HDNodeType node = 5;			// current BIP-32 node
+	optional bool passphrase_protection = 6;	// is node/mnemonic encrypted using passphrase?
+	optional string reset_word = 7;			// word on device display during ResetDevice workflow
+	optional bytes reset_entropy = 8;		// current entropy during ResetDevice workflow
+	optional string recovery_fake_word = 9;		// (fake) word on display during RecoveryDevice workflow
+	optional uint32 recovery_word_pos = 10;		// index of mnemonic word the device is expecting during RecoveryDevice workflow
+}
+
+/**
+ * Request: Ask device to restart
+ */
+message DebugLinkStop {
+}
+
+/**
+ * Response: Device wants host to log event
+ */
+message DebugLinkLog {
+	optional uint32 level = 1;
+	optional string bucket = 2;
+	optional string text = 3;
+}
+
+/**
+ * Request: Read memory from device
+ * @next DebugLinkMemory
+ */
+message DebugLinkMemoryRead {
+	optional uint32 address = 1;
+	optional uint32 length = 2;
+}
+
+/**
+ * Response: Device sends memory back
+ * @prev DebugLinkMemoryRead
+ */
+message DebugLinkMemory {
+	optional bytes memory = 1;
+}
+
+/**
+ * Request: Write memory to device.
+ * WARNING: Writing to the wrong location can irreparably break the device.
+ */
+message DebugLinkMemoryWrite {
+	optional uint32 address = 1;
+	optional bytes memory = 2;
+	optional bool flash = 3;
+}
+
+/**
+ * Request: Erase block of flash on device
+ * WARNING: Writing to the wrong location can irreparably break the device.
+ */
+message DebugLinkFlashErase {
+	optional uint32 sector = 1;
+}

accounts/usbwallet/internal/trezor/trezor.go

@@ -0,0 +1,46 @@
+// 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
+
+//go:generate protoc --go_out=import_path=trezor:. types.proto messages.proto
+
+// Package trezor contains the wire protocol wrapper in Go.
+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:]
+}

accounts/usbwallet/internal/trezor/types.proto

@@ -0,0 +1,278 @@
+// This file originates from the SatoshiLabs Trezor `common` repository at:
+//   https://github.com/trezor/trezor-common/blob/master/protob/types.proto
+// dated 28.07.2017, commit dd8ec3231fb5f7992360aff9bdfe30bb58130f4b.
+
+syntax = "proto2";
+
+/**
+ * Types for TREZOR communication
+ *
+ * @author	Marek Palatinus <slush@satoshilabs.com>
+ * @version	1.2
+ */
+
+// Sugar for easier handling in Java
+option java_package = "com.satoshilabs.trezor.lib.protobuf";
+option java_outer_classname = "TrezorType";
+
+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
+}
+
+/**
+ * Type of failures returned by Failure message
+ * @used_in Failure
+ */
+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_FirmwareError = 99;
+}
+
+/**
+ * Type of script which will be used for transaction output
+ * @used_in TxOutputType
+ */
+enum OutputScriptType {
+	PAYTOADDRESS = 0;	// used for all addresses (bitcoin, p2sh, witness)
+	PAYTOSCRIPTHASH = 1;	// p2sh address (deprecated; use PAYTOADDRESS)
+	PAYTOMULTISIG = 2;	// only for change output
+	PAYTOOPRETURN = 3;	// op_return
+	PAYTOWITNESS = 4;	// only for change output
+	PAYTOP2SHWITNESS = 5;	// only for change output
+}
+
+/**
+ * Type of script which will be used for transaction output
+ * @used_in TxInputType
+ */
+enum InputScriptType {
+	SPENDADDRESS = 0;		// standard p2pkh address
+	SPENDMULTISIG = 1;		// p2sh multisig address
+	EXTERNAL = 2;			// reserved for external inputs (coinjoin)
+	SPENDWITNESS = 3;		// native segwit
+	SPENDP2SHWITNESS = 4;		// segwit over p2sh (backward compatible)
+}
+
+/**
+ * Type of information required by transaction signing process
+ * @used_in TxRequest
+ */
+enum RequestType {
+	TXINPUT = 0;
+	TXOUTPUT = 1;
+	TXMETA = 2;
+	TXFINISHED = 3;
+	TXEXTRADATA = 4;
+}
+
+/**
+ * Type of button request
+ * @used_in ButtonRequest
+ */
+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;
+}
+
+/**
+ * Type of PIN request
+ * @used_in PinMatrixRequest
+ */
+enum PinMatrixRequestType {
+	PinMatrixRequestType_Current = 1;
+	PinMatrixRequestType_NewFirst = 2;
+	PinMatrixRequestType_NewSecond = 3;
+}
+
+/**
+ * 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.
+ *
+ * @used_in RecoveryDevice
+ */
+enum RecoveryDeviceType {
+	// use powers of two when extending this field
+	RecoveryDeviceType_ScrambledWords = 0;		// words in scrambled order
+	RecoveryDeviceType_Matrix = 1;				// matrix recovery type
+}
+
+/**
+ * Type of Recovery Word request
+ * @used_in WordRequest
+ */
+enum WordRequestType {
+	WordRequestType_Plain = 0;
+	WordRequestType_Matrix9 = 1;
+	WordRequestType_Matrix6 = 2;
+}
+
+/**
+ * Structure representing BIP32 (hierarchical deterministic) node
+ * Used for imports of private key into the device and exporting public key out of device
+ * @used_in PublicKey
+ * @used_in LoadDevice
+ * @used_in DebugLinkState
+ * @used_in Storage
+ */
+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;
+}
+
+message HDNodePathType {
+	required HDNodeType node = 1;						// BIP-32 node in deserialized form
+	repeated uint32 address_n = 2;						// BIP-32 path to derive the key from node
+}
+
+/**
+ * Structure representing Coin
+ * @used_in Features
+ */
+message CoinType {
+	optional string coin_name = 1;
+	optional string coin_shortcut = 2;
+	optional uint32 address_type = 3 [default=0];
+	optional uint64 maxfee_kb = 4;
+	optional uint32 address_type_p2sh = 5 [default=5];
+	optional string signed_message_header = 8;
+	optional uint32 xpub_magic = 9 [default=76067358];	// default=0x0488b21e
+	optional uint32 xprv_magic = 10 [default=76066276];	// default=0x0488ade4
+	optional bool segwit = 11;
+	optional uint32 forkid = 12;
+}
+
+/**
+ * Type of redeem script used in input
+ * @used_in TxInputType
+ */
+message MultisigRedeemScriptType {
+	repeated HDNodePathType pubkeys = 1;					// pubkeys from multisig address (sorted lexicographically)
+	repeated bytes signatures = 2;						// existing signatures for partially signed input
+	optional uint32 m = 3;							// "m" from n, how many valid signatures is necessary for spending
+}
+
+/**
+ * Structure representing transaction input
+ * @used_in SimpleSignTx
+ * @used_in TransactionType
+ */
+message TxInputType {
+	repeated uint32 address_n = 1;						// BIP-32 path to derive the key from master node
+	required bytes prev_hash = 2;						// hash of previous transaction output to spend by this input
+	required uint32 prev_index = 3;						// index of previous output to spend
+	optional bytes script_sig = 4;						// script signature, unset for tx to sign
+	optional uint32 sequence = 5 [default=4294967295];			// sequence (default=0xffffffff)
+	optional InputScriptType script_type = 6 [default=SPENDADDRESS];	// defines template of input script
+	optional MultisigRedeemScriptType multisig = 7;				// Filled if input is going to spend multisig tx
+	optional uint64 amount = 8;						// amount of previous transaction output (for segwit only)
+}
+
+/**
+ * Structure representing transaction output
+ * @used_in SimpleSignTx
+ * @used_in TransactionType
+ */
+message TxOutputType {
+	optional string address = 1;			// target coin address in Base58 encoding
+	repeated uint32 address_n = 2;			// BIP-32 path to derive the key from master node; has higher priority than "address"
+	required uint64 amount = 3;			// amount to spend in satoshis
+	required OutputScriptType script_type = 4;	// output script type
+	optional MultisigRedeemScriptType multisig = 5; // defines multisig address; script_type must be PAYTOMULTISIG
+	optional bytes op_return_data = 6;		// defines op_return data; script_type must be PAYTOOPRETURN, amount must be 0
+}
+
+/**
+ * Structure representing compiled transaction output
+ * @used_in TransactionType
+ */
+message TxOutputBinType {
+	required uint64 amount = 1;
+	required bytes script_pubkey = 2;
+}
+
+/**
+ * Structure representing transaction
+ * @used_in SimpleSignTx
+ */
+message TransactionType {
+	optional uint32 version = 1;
+	repeated TxInputType inputs = 2;
+	repeated TxOutputBinType bin_outputs = 3;
+	repeated TxOutputType outputs = 5;
+	optional uint32 lock_time = 4;
+	optional uint32 inputs_cnt = 6;
+	optional uint32 outputs_cnt = 7;
+	optional bytes extra_data = 8;
+	optional uint32 extra_data_len = 9;
+}
+
+/**
+ * Structure representing request details
+ * @used_in TxRequest
+ */
+message TxRequestDetailsType {
+	optional uint32 request_index = 1;	// device expects TxAck message from the computer
+	optional bytes tx_hash = 2;		// tx_hash of requested transaction
+	optional uint32 extra_data_len = 3;	// length of requested extra data
+	optional uint32 extra_data_offset = 4;	// offset of requested extra data
+}
+
+/**
+ * Structure representing serialized data
+ * @used_in TxRequest
+ */
+message TxRequestSerializedType {
+	optional uint32 signature_index = 1;	// 'signature' field contains signed input of this index
+	optional bytes signature = 2;		// signature of the signature_index input
+	optional bytes serialized_tx = 3;	// part of serialized and signed transaction
+}
+
+/**
+ * Structure representing identity data
+ * @used_in IdentityType
+ */
+message IdentityType {
+	optional string proto = 1;			// proto part of URI
+	optional string user = 2;			// user part of URI
+	optional string host = 3;			// host part of URI
+	optional string port = 4;			// port part of URI
+	optional string path = 5;			// path part of URI
+	optional uint32 index = 6 [default=0];		// identity index
+}

accounts/usbwallet/ledger.go

@@ -32,7 +32,6 @@ import (
 	"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/log"
 	"github.com/ethereum/go-ethereum/rlp"
 )
@@ -163,7 +162,6 @@ func (w *ledgerDriver) SignTx(path accounts.DerivationPath, tx *types.Transactio
 	}
 	// Ensure the wallet is capable of signing the given transaction
 	if chainID != nil && w.version[0] <= 1 && w.version[1] <= 0 && w.version[2] <= 2 {
-		//lint:ignore ST1005 brand name displayed on the console
 		return common.Address{}, nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least", w.version[0], w.version[1], w.version[2])
 	}
 	// All infos gathered and metadata checks out, request signing
@@ -343,7 +341,7 @@ func (w *ledgerDriver) ledgerSign(derivationPath []uint32, tx *types.Transaction
 		op = ledgerP1ContTransactionData
 	}
 	// Extract the Ethereum signature and do a sanity validation
-	if len(reply) != crypto.SignatureLength {
+	if len(reply) != 65 {
 		return common.Address{}, nil, errors.New("reply lacks signature")
 	}
 	signature := append(reply[1:], reply[0])

accounts/usbwallet/trezor.go

@@ -28,7 +28,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts"
-	"github.com/ethereum/go-ethereum/accounts/usbwallet/trezor"
+	"github.com/ethereum/go-ethereum/accounts/usbwallet/internal/trezor"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -41,9 +41,6 @@ import (
 // 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.
@@ -55,7 +52,6 @@ type trezorDriver struct {
 	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
 }
@@ -83,21 +79,19 @@ func (w *trezorDriver) Status() (string, error) {
 }
 
 // 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 Trezor hardware wallet. Initializing the Trezor is a two 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
+//    features. This phase is invoked is 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 passphrase == "" {
 		// If we're already waiting for a PIN entry, insta-return
 		if w.pinwait {
 			return ErrTrezorPINNeeded
@@ -110,46 +104,26 @@ func (w *trezorDriver) Open(device io.ReadWriter, passphrase string) error {
 		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
+		// Do a manual ping, forcing the device to ask for its PIN
 		askPin := true
-		askPassphrase := true
-		res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin, PassphraseProtection: &askPassphrase}, new(trezor.PinMatrixRequest), new(trezor.PassphraseRequest), new(trezor.Success))
+		res, err := w.trezorExchange(&trezor.Ping{PinProtection: &askPin}, new(trezor.PinMatrixRequest), 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:
+		if res == 1 {
+			return nil // Device responded with trezor.Success
+		}
 		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
-		}
-	}
 
+	if _, err := w.trezorExchange(&trezor.PinMatrixAck{Pin: &passphrase}, new(trezor.Success)); err != nil {
+		w.failure = err
+		return err
+	}
 	return nil
 }
 
@@ -192,13 +166,7 @@ func (w *trezorDriver) trezorDerive(derivationPath []uint32) (common.Address, er
 	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")
+	return common.BytesToAddress(address.GetAddress()), nil
 }
 
 // trezorSign sends the transaction to the Trezor wallet, and waits for the user
@@ -217,10 +185,7 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction
 		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)
+		request.To = (*to)[:] // Non contract deploy, set recipient explicitly
 	}
 	if length > 1024 { // Send the data chunked if that was requested
 		request.DataInitialChunk, data = data[:1024], data[1024:]
@@ -255,11 +220,9 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction
 	if chainID == nil {
 		signer = new(types.HomesteadSigner)
 	} else {
-		// Trezor backend does not support typed transactions yet.
 		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 {

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,
-}

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;
-}

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,
-}

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)
-}

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
-}

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,
-}

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];
-}

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:]
-}

accounts/usbwallet/wallet.go

@@ -25,13 +25,12 @@ import (
 	"sync"
 	"time"
 
-	"github.com/ethereum/go-ethereum"
+	ethereum "github.com/ethereum/go-ethereum"
 	"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/log"
-	"github.com/karalabe/usb"
+	"github.com/karalabe/hid"
 )
 
 // Maximum time between wallet health checks to detect USB unplugs.
@@ -77,14 +76,14 @@ type wallet struct {
 	driver driver        // Hardware implementation of the low level device operations
 	url    *accounts.URL // Textual URL uniquely identifying this wallet
 
-	info   usb.DeviceInfo // Known USB device infos about the wallet
-	device usb.Device     // USB device advertising itself as a hardware wallet
+	info   hid.DeviceInfo // Known USB device infos about the wallet
+	device *hid.Device    // USB device advertising itself as a hardware wallet
 
 	accounts []accounts.Account                         // List of derive accounts pinned on the hardware wallet
 	paths    map[common.Address]accounts.DerivationPath // Known derivation paths for signing operations
 
-	deriveNextPaths []accounts.DerivationPath // Next derivation paths for account auto-discovery (multiple bases supported)
-	deriveNextAddrs []common.Address          // Next derived account addresses for auto-discovery (multiple bases supported)
+	deriveNextPath accounts.DerivationPath   // Next derivation path for account auto-discovery
+	deriveNextAddr common.Address            // Next derived account address for auto-discovery
 	deriveChain    ethereum.ChainStateReader // Blockchain state reader to discover used account with
 	deriveReq      chan chan struct{}        // Channel to request a self-derivation on
 	deriveQuit     chan chan error           // Channel to terminate the self-deriver with
@@ -274,7 +273,9 @@ func (w *wallet) close() error {
 	w.device = nil
 
 	w.accounts, w.paths = nil, nil
-	return w.driver.Close()
+	w.driver.Close()
+
+	return nil
 }
 
 // Accounts implements accounts.Wallet, returning the list of accounts pinned to
@@ -339,16 +340,15 @@ func (w *wallet) selfDerive() {
 			accs  []accounts.Account
 			paths []accounts.DerivationPath
 
-			nextPaths = append([]accounts.DerivationPath{}, w.deriveNextPaths...)
-			nextAddrs = append([]common.Address{}, w.deriveNextAddrs...)
+			nextAddr = w.deriveNextAddr
+			nextPath = w.deriveNextPath
 
 			context = context.Background()
 		)
-		for i := 0; i < len(nextAddrs); i++ {
 		for empty := false; !empty; {
 			// Retrieve the next derived Ethereum account
-				if nextAddrs[i] == (common.Address{}) {
-					if nextAddrs[i], err = w.driver.Derive(nextPaths[i]); err != nil {
+			if nextAddr == (common.Address{}) {
+				if nextAddr, err = w.driver.Derive(nextPath); err != nil {
 					w.log.Warn("USB wallet account derivation failed", "err", err)
 					break
 				}
@@ -358,47 +358,39 @@ func (w *wallet) selfDerive() {
 				balance *big.Int
 				nonce   uint64
 			)
-				balance, err = w.deriveChain.BalanceAt(context, nextAddrs[i], nil)
+			balance, err = w.deriveChain.BalanceAt(context, nextAddr, nil)
 			if err != nil {
 				w.log.Warn("USB wallet balance retrieval failed", "err", err)
 				break
 			}
-				nonce, err = w.deriveChain.NonceAt(context, nextAddrs[i], nil)
+			nonce, err = w.deriveChain.NonceAt(context, nextAddr, nil)
 			if err != nil {
 				w.log.Warn("USB wallet nonce retrieval failed", "err", err)
 				break
 			}
-				// We've just self-derived a new account, start tracking it locally
-				// unless the account was empty.
-				path := make(accounts.DerivationPath, len(nextPaths[i]))
-				copy(path[:], nextPaths[i][:])
+			// If the next account is empty, stop self-derivation, but add it nonetheless
 			if balance.Sign() == 0 && nonce == 0 {
 				empty = true
-					// If it indeed was empty, make a log output for it anyway. In the case
-					// of legacy-ledger, the first account on the legacy-path will
-					// be shown to the user, even if we don't actively track it
-					if i < len(nextAddrs)-1 {
-						w.log.Info("Skipping trakcking first account on legacy path, use personal.deriveAccount(<url>,<path>, false) to track",
-							"path", path, "address", nextAddrs[i])
-						break
-					}
 			}
+			// We've just self-derived a new account, start tracking it locally
+			path := make(accounts.DerivationPath, len(nextPath))
+			copy(path[:], nextPath[:])
 			paths = append(paths, path)
+
 			account := accounts.Account{
-					Address: nextAddrs[i],
+				Address: nextAddr,
 				URL:     accounts.URL{Scheme: w.url.Scheme, Path: fmt.Sprintf("%s/%s", w.url.Path, path)},
 			}
 			accs = append(accs, account)
 
 			// Display a log message to the user for new (or previously empty accounts)
-				if _, known := w.paths[nextAddrs[i]]; !known || (!empty && nextAddrs[i] == w.deriveNextAddrs[i]) {
-					w.log.Info("USB wallet discovered new account", "address", nextAddrs[i], "path", path, "balance", balance, "nonce", nonce)
+			if _, known := w.paths[nextAddr]; !known || (!empty && nextAddr == w.deriveNextAddr) {
+				w.log.Info("USB wallet discovered new account", "address", nextAddr, "path", path, "balance", balance, "nonce", nonce)
 			}
 			// Fetch the next potential account
 			if !empty {
-					nextAddrs[i] = common.Address{}
-					nextPaths[i][len(nextPaths[i])-1]++
-				}
+				nextAddr = common.Address{}
+				nextPath[len(nextPath)-1]++
 			}
 		}
 		// Self derivation complete, release device lock
@@ -415,8 +407,8 @@ func (w *wallet) selfDerive() {
 		}
 		// Shift the self-derivation forward
 		// TODO(karalabe): don't overwrite changes from wallet.SelfDerive
-		w.deriveNextAddrs = nextAddrs
-		w.deriveNextPaths = nextPaths
+		w.deriveNextAddr = nextAddr
+		w.deriveNextPath = nextPath
 		w.stateLock.Unlock()
 
 		// Notify the user of termination and loop after a bit of time (to avoid trashing)
@@ -483,61 +475,32 @@ func (w *wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Accoun
 
 	if _, ok := w.paths[address]; !ok {
 		w.accounts = append(w.accounts, account)
-		w.paths[address] = make(accounts.DerivationPath, len(path))
-		copy(w.paths[address], path)
+		w.paths[address] = path
 	}
 	return account, nil
 }
 
-// SelfDerive sets a base account derivation path from which the wallet attempts
-// to discover non zero accounts and automatically add them to list of tracked
-// accounts.
-//
-// Note, self derivation will increment the last component of the specified path
-// opposed to decending into a child path to allow discovering accounts starting
-// from non zero components.
-//
-// Some hardware wallets switched derivation paths through their evolution, so
-// this method supports providing multiple bases to discover old user accounts
-// too. Only the last base will be used to derive the next empty account.
-//
-// You can disable automatic account discovery by calling SelfDerive with a nil
-// chain state reader.
-func (w *wallet) SelfDerive(bases []accounts.DerivationPath, chain ethereum.ChainStateReader) {
+// SelfDerive implements accounts.Wallet, trying to discover accounts that the
+// user used previously (based on the chain state), but ones that he/she did not
+// explicitly pin to the wallet manually. To avoid chain head monitoring, self
+// derivation only runs during account listing (and even then throttled).
+func (w *wallet) SelfDerive(base accounts.DerivationPath, chain ethereum.ChainStateReader) {
 	w.stateLock.Lock()
 	defer w.stateLock.Unlock()
 
-	w.deriveNextPaths = make([]accounts.DerivationPath, len(bases))
-	for i, base := range bases {
-		w.deriveNextPaths[i] = make(accounts.DerivationPath, len(base))
-		copy(w.deriveNextPaths[i][:], base[:])
-	}
-	w.deriveNextAddrs = make([]common.Address, len(bases))
+	w.deriveNextPath = make(accounts.DerivationPath, len(base))
+	copy(w.deriveNextPath[:], base[:])
+
+	w.deriveNextAddr = common.Address{}
 	w.deriveChain = chain
 }
 
-// signHash implements accounts.Wallet, however signing arbitrary data is not
+// SignHash implements accounts.Wallet, however signing arbitrary data is not
 // supported for hardware wallets, so this method will always return an error.
-func (w *wallet) signHash(account accounts.Account, hash []byte) ([]byte, error) {
+func (w *wallet) SignHash(account accounts.Account, hash []byte) ([]byte, error) {
 	return nil, accounts.ErrNotSupported
 }
 
-// SignData signs keccak256(data). The mimetype parameter describes the type of data being signed
-func (w *wallet) SignData(account accounts.Account, mimeType string, data []byte) ([]byte, error) {
-	return w.signHash(account, crypto.Keccak256(data))
-}
-
-// SignDataWithPassphrase implements accounts.Wallet, attempting to sign the given
-// data with the given account using passphrase as extra authentication.
-// Since USB wallets don't rely on passphrases, these are silently ignored.
-func (w *wallet) SignDataWithPassphrase(account accounts.Account, passphrase, mimeType string, data []byte) ([]byte, error) {
-	return w.SignData(account, mimeType, data)
-}
-
-func (w *wallet) SignText(account accounts.Account, text []byte) ([]byte, error) {
-	return w.signHash(account, accounts.TextHash(text))
-}
-
 // SignTx implements accounts.Wallet. It sends the transaction over to the Ledger
 // wallet to request a confirmation from the user. It returns either the signed
 // transaction or a failure if the user denied the transaction.
@@ -587,8 +550,8 @@ func (w *wallet) SignTx(account accounts.Account, tx *types.Transaction, chainID
 // SignHashWithPassphrase implements accounts.Wallet, however signing arbitrary
 // data is not supported for Ledger wallets, so this method will always return
 // an error.
-func (w *wallet) SignTextWithPassphrase(account accounts.Account, passphrase string, text []byte) ([]byte, error) {
-	return w.SignText(account, accounts.TextHash(text))
+func (w *wallet) SignHashWithPassphrase(account accounts.Account, passphrase string, hash []byte) ([]byte, error) {
+	return w.SignHash(account, hash)
 }
 
 // SignTxWithPassphrase implements accounts.Wallet, attempting to sign the given

appveyor.yml

@@ -6,7 +6,6 @@ clone_depth: 5
 version: "{branch}.{build}"
 environment:
   global:
-    GO111MODULE: on
     GOPATH: C:\gopath
     CC: gcc.exe
   matrix:
@@ -24,13 +23,13 @@ environment:
 install:
   - git submodule update --init
   - rmdir C:\go /s /q
-  - appveyor DownloadFile https://dl.google.com/go/go1.16.windows-%GETH_ARCH%.zip
-  - 7z x go1.16.windows-%GETH_ARCH%.zip -y -oC:\ > NUL
+  - appveyor DownloadFile https://storage.googleapis.com/golang/go1.11.5.windows-%GETH_ARCH%.zip
+  - 7z x go1.11.5.windows-%GETH_ARCH%.zip -y -oC:\ > NUL
   - go version
   - gcc --version
 
 build_script:
-  - go run build\ci.go install -dlgo
+  - go run build\ci.go install
 
 after_build:
   - go run build\ci.go archive -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds

build/checksums.txt

@@ -1,31 +0,0 @@
-# This file contains sha256 checksums of optional build dependencies.
-
-7688063d55656105898f323d90a79a39c378d86fe89ae192eb3b7fc46347c95a  go1.16.src.tar.gz
-6000a9522975d116bf76044967d7e69e04e982e9625330d9a539a8b45395f9a8  go1.16.darwin-amd64.tar.gz
-ea435a1ac6d497b03e367fdfb74b33e961d813883468080f6e239b3b03bea6aa  go1.16.linux-386.tar.gz
-013a489ebb3e24ef3d915abe5b94c3286c070dfe0818d5bca8108f1d6e8440d2  go1.16.linux-amd64.tar.gz
-3770f7eb22d05e25fbee8fb53c2a4e897da043eb83c69b9a14f8d98562cd8098  go1.16.linux-arm64.tar.gz
-d1d9404b1dbd77afa2bdc70934e10fbfcf7d785c372efc29462bb7d83d0a32fd  go1.16.linux-armv6l.tar.gz
-481492a17d42193d471b93b7a06da3555331bd833b76336afc87be820c48933f  go1.16.windows-386.zip
-5cc88fa506b3d5c453c54c3ea218fc8dd05d7362ae1de15bb67986b72089ce93  go1.16.windows-amd64.zip
-d7d6c70b05a7c2f68b48aab5ab8cb5116b8444c9ddad131673b152e7cff7c726  go1.16.freebsd-386.tar.gz
-40b03216f6945fb6883a50604fc7f409a83f62171607229a9c598e701e684f8a  go1.16.freebsd-amd64.tar.gz
-27a1aaa988e930b7932ce459c8a63ad5b3333b3a06b016d87ff289f2a11aacd6  go1.16.linux-ppc64le.tar.gz
-be4c9e4e2cf058efc4e3eb013a760cb989ddc4362f111950c990d1c63b27ccbe  go1.16.linux-s390x.tar.gz
-
-d998a84eea42f2271aca792a7b027ca5c1edfcba229e8e5a844c9ac3f336df35  golangci-lint-1.27.0-linux-armv7.tar.gz
-bf781f05b0d393b4bf0a327d9e62926949a4f14d7774d950c4e009fc766ed1d4  golangci-lint.exe-1.27.0-windows-amd64.zip
-bf781f05b0d393b4bf0a327d9e62926949a4f14d7774d950c4e009fc766ed1d4  golangci-lint-1.27.0-windows-amd64.zip
-0e2a57d6ba709440d3ed018ef1037465fa010ed02595829092860e5cf863042e  golangci-lint-1.27.0-freebsd-386.tar.gz
-90205fc42ab5ed0096413e790d88ac9b4ed60f4c47e576d13dc0660f7ed4b013  golangci-lint-1.27.0-linux-arm64.tar.gz
-8d345e4e88520e21c113d81978e89ad77fc5b13bfdf20e5bca86b83fc4261272  golangci-lint-1.27.0-linux-amd64.tar.gz
-cc619634a77f18dc73df2a0725be13116d64328dc35131ca1737a850d6f76a59  golangci-lint-1.27.0-freebsd-armv7.tar.gz
-fe683583cfc9eeec83e498c0d6159d87b5e1919dbe4b6c3b3913089642906069  golangci-lint-1.27.0-linux-s390x.tar.gz
-058f5579bee75bdaacbaf75b75e1369f7ad877fd8b3b145aed17a17545de913e  golangci-lint-1.27.0-freebsd-armv6.tar.gz
-38e1e3dadbe3f56ab62b4de82ee0b88e8fad966d8dfd740a26ef94c2edef9818  golangci-lint-1.27.0-linux-armv6.tar.gz
-071b34af5516f4e1ddcaea6011e18208f4f043e1af8ba21eeccad4585cb3d095  golangci-lint.exe-1.27.0-windows-386.zip
-071b34af5516f4e1ddcaea6011e18208f4f043e1af8ba21eeccad4585cb3d095  golangci-lint-1.27.0-windows-386.zip
-5f37e2b33914ecddb7cad38186ef4ec61d88172fc04f930fa0267c91151ff306  golangci-lint-1.27.0-linux-386.tar.gz
-4d94cfb51fdebeb205f1d5a349ac2b683c30591c5150708073c1c329e15965f0  golangci-lint-1.27.0-freebsd-amd64.tar.gz
-52572ba8ff07d5169c2365d3de3fec26dc55a97522094d13d1596199580fa281  golangci-lint-1.27.0-linux-ppc64le.tar.gz
-3fb1a1683a29c6c0a8cd76135f62b606fbdd538d5a7aeab94af1af70ffdc2fd4  golangci-lint-1.27.0-darwin-amd64.tar.gz

build/ci-notes.md

@@ -22,18 +22,19 @@ variables `PPA_SIGNING_KEY` and `PPA_SSH_KEY` on Travis.
 
 We want to build go-ethereum with the most recent version of Go, irrespective of the Go
 version that is available in the main Ubuntu repository. In order to make this possible,
-we bundle the entire Go sources into our own source archive and start the built job by
-compiling Go and then using that to build go-ethereum. On Trusty we have a special case
-requiring the `~gophers/ubuntu/archive` PPA since Trusty can't even build Go itself. PPA
-deps are set at https://launchpad.net/%7Eethereum/+archive/ubuntu/ethereum/+edit-dependencies
+our PPA depends on the ~gophers/ubuntu/archive PPA. Our source package build-depends on
+golang-1.10, which is co-installable alongside the regular golang package. PPA dependencies
+can be edited at https://launchpad.net/%7Eethereum/+archive/ubuntu/ethereum/+edit-dependencies
 
 ## Building Packages Locally (for testing)
 
 You need to run Ubuntu to do test packaging.
 
-Install any version of Go and Debian packaging tools:
+Add the gophers PPA and install Go 1.10 and Debian packaging tools:
 
-    $ sudo apt-get install build-essential golang-go devscripts debhelper python-bzrlib python-paramiko
+    $ sudo apt-add-repository ppa:gophers/ubuntu/archive
+    $ sudo apt-get update
+    $ sudo apt-get install build-essential golang-1.10 devscripts debhelper python-bzrlib python-paramiko
 
 Create the source packages:
 
@@ -41,10 +42,10 @@ Create the source packages:
 
 Then go into the source package directory for your running distribution and build the package:
 
-    $ cd dist/ethereum-unstable-1.9.6+bionic
+    $ cd dist/ethereum-unstable-1.6.0+xenial
     $ dpkg-buildpackage
 
 Built packages are placed in the dist/ directory.
 
     $ cd ..
-    $ dpkg-deb -c geth-unstable_1.9.6+bionic_amd64.deb
+    $ dpkg-deb -c geth-unstable_1.6.0+xenial_amd64.deb

build/ci.go

@@ -26,7 +26,7 @@ Available commands are:
    install    [ -arch architecture ] [ -cc compiler ] [ packages... ]                          -- builds packages and executables
    test       [ -coverage ] [ packages... ]                                                    -- runs the tests
    lint                                                                                        -- runs certain pre-selected linters
-   archive    [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -signify key-envvar ] [ -upload dest ] -- archives build artifacts
+   archive    [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -upload dest ] -- archives build artifacts
    importkeys                                                                                  -- imports signing keys from env
    debsrc     [ -signer key-id ] [ -upload dest ]                                              -- creates a debian source package
    nsis                                                                                        -- creates a Windows NSIS installer
@@ -46,21 +46,21 @@ import (
 	"encoding/base64"
 	"flag"
 	"fmt"
+	"go/parser"
+	"go/token"
 	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
-	"path"
 	"path/filepath"
 	"regexp"
 	"runtime"
 	"strings"
 	"time"
 
-	"github.com/cespare/cp"
-	"github.com/ethereum/go-ethereum/crypto/signify"
 	"github.com/ethereum/go-ethereum/internal/build"
 	"github.com/ethereum/go-ethereum/params"
+	sv "github.com/ethereum/go-ethereum/swarm/version"
 )
 
 var (
@@ -79,7 +79,13 @@ var (
 		executablePath("geth"),
 		executablePath("puppeth"),
 		executablePath("rlpdump"),
-		executablePath("clef"),
+		executablePath("wnode"),
+	}
+
+	// Files that end up in the swarm*.zip archive.
+	swarmArchiveFiles = []string{
+		"COPYING",
+		executablePath("swarm"),
 	}
 
 	// A debian package is created for all executables listed here.
@@ -109,12 +115,19 @@ var (
 			Description: "Developer utility tool that prints RLP structures.",
 		},
 		{
-			BinaryName:  "clef",
-			Description: "Ethereum account management tool.",
+			BinaryName:  "wnode",
+			Description: "Ethereum Whisper diagnostic tool",
 		},
 	}
 
 	// A debian package is created for all executables listed here.
+	debSwarmExecutables = []debExecutable{
+		{
+			BinaryName:  "swarm",
+			PackageName: "ethereum-swarm",
+			Description: "Ethereum Swarm daemon and tools",
+		},
+	}
 
 	debEthereum = debPackage{
 		Name:        "ethereum",
@@ -122,37 +135,28 @@ var (
 		Executables: debExecutables,
 	}
 
+	debSwarm = debPackage{
+		Name:        "ethereum-swarm",
+		Version:     sv.Version,
+		Executables: debSwarmExecutables,
+	}
+
 	// Debian meta packages to build and push to Ubuntu PPA
 	debPackages = []debPackage{
+		debSwarm,
 		debEthereum,
 	}
 
+	// Packages to be cross-compiled by the xgo command
+	allCrossCompiledArchiveFiles = append(allToolsArchiveFiles, swarmArchiveFiles...)
+
 	// Distros for which packages are created.
 	// Note: vivid is unsupported because there is no golang-1.6 package for it.
-	// Note: wily is unsupported because it was officially deprecated on Launchpad.
-	// Note: yakkety is unsupported because it was officially deprecated on Launchpad.
-	// Note: zesty is unsupported because it was officially deprecated on Launchpad.
-	// Note: artful is unsupported because it was officially deprecated on Launchpad.
-	// Note: cosmic is unsupported because it was officially deprecated on Launchpad.
-	// Note: disco is unsupported because it was officially deprecated on Launchpad.
-	// Note: eoan is unsupported because it was officially deprecated on Launchpad.
-	debDistroGoBoots = map[string]string{
-		"trusty": "golang-1.11",
-		"xenial": "golang-go",
-		"bionic": "golang-go",
-		"focal":  "golang-go",
-		"groovy": "golang-go",
-	}
-
-	debGoBootPaths = map[string]string{
-		"golang-1.11": "/usr/lib/go-1.11",
-		"golang-go":   "/usr/lib/go",
-	}
-
-	// This is the version of go that will be downloaded by
-	//
-	//     go run ci.go install -dlgo
-	dlgoVersion = "1.16"
+	// Note: wily is unsupported because it was officially deprecated on lanchpad.
+	// Note: yakkety is unsupported because it was officially deprecated on lanchpad.
+	// Note: zesty is unsupported because it was officially deprecated on lanchpad.
+	// Note: artful is unsupported because it was officially deprecated on lanchpad.
+	debDistros = []string{"trusty", "xenial", "bionic", "cosmic"}
 )
 
 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@@ -203,130 +207,112 @@ func main() {
 
 func doInstall(cmdline []string) {
 	var (
-		dlgo = flag.Bool("dlgo", false, "Download Go and build with it")
 		arch = flag.String("arch", "", "Architecture to cross build for")
 		cc   = flag.String("cc", "", "C compiler to cross build with")
 	)
 	flag.CommandLine.Parse(cmdline)
 	env := build.Env()
 
-	// Check local Go version. People regularly open issues about compilation
+	// Check Go version. People regularly open issues about compilation
 	// failure with outdated Go. This should save them the trouble.
 	if !strings.Contains(runtime.Version(), "devel") {
 		// Figure out the minor version number since we can't textually compare (1.10 < 1.9)
 		var minor int
 		fmt.Sscanf(strings.TrimPrefix(runtime.Version(), "go1."), "%d", &minor)
-		if minor < 13 {
+
+		if minor < 9 {
 			log.Println("You have Go version", runtime.Version())
-			log.Println("go-ethereum requires at least Go version 1.13 and cannot")
+			log.Println("go-ethereum requires at least Go version 1.9 and cannot")
 			log.Println("be compiled with an earlier version. Please upgrade your Go installation.")
 			os.Exit(1)
 		}
 	}
-
-	// Choose which go command we're going to use.
-	var gobuild *exec.Cmd
-	if !*dlgo {
-		// Default behavior: use the go version which runs ci.go right now.
-		gobuild = goTool("build")
-	} else {
-		// Download of Go requested. This is for build environments where the
-		// installed version is too old and cannot be upgraded easily.
-		cachedir := filepath.Join("build", "cache")
-		goroot := downloadGo(runtime.GOARCH, runtime.GOOS, cachedir)
-		gobuild = localGoTool(goroot, "build")
+	// Compile packages given as arguments, or everything if there are no arguments.
+	packages := []string{"./..."}
+	if flag.NArg() > 0 {
+		packages = flag.Args()
 	}
+	packages = build.ExpandPackagesNoVendor(packages)
 
-	// Configure environment for cross build.
-	if *arch != "" || *arch != runtime.GOARCH {
-		gobuild.Env = append(gobuild.Env, "CGO_ENABLED=1")
-		gobuild.Env = append(gobuild.Env, "GOARCH="+*arch)
+	if *arch == "" || *arch == runtime.GOARCH {
+		goinstall := goTool("install", buildFlags(env)...)
+		goinstall.Args = append(goinstall.Args, "-v")
+		goinstall.Args = append(goinstall.Args, packages...)
+		build.MustRun(goinstall)
+		return
 	}
-
-	// Configure C compiler.
-	if *cc != "" {
-		gobuild.Env = append(gobuild.Env, "CC="+*cc)
-	} else if os.Getenv("CC") != "" {
-		gobuild.Env = append(gobuild.Env, "CC="+os.Getenv("CC"))
+	// If we are cross compiling to ARMv5 ARMv6 or ARMv7, clean any previous builds
+	if *arch == "arm" {
+		os.RemoveAll(filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_arm"))
+		for _, path := range filepath.SplitList(build.GOPATH()) {
+			os.RemoveAll(filepath.Join(path, "pkg", runtime.GOOS+"_arm"))
 		}
-
-	// arm64 CI builders are memory-constrained and can't handle concurrent builds,
-	// better disable it. This check isn't the best, it should probably
-	// check for something in env instead.
-	if runtime.GOARCH == "arm64" {
-		gobuild.Args = append(gobuild.Args, "-p", "1")
 	}
+	// Seems we are cross compiling, work around forbidden GOBIN
+	goinstall := goToolArch(*arch, *cc, "install", buildFlags(env)...)
+	goinstall.Args = append(goinstall.Args, "-v")
+	goinstall.Args = append(goinstall.Args, []string{"-buildmode", "archive"}...)
+	goinstall.Args = append(goinstall.Args, packages...)
+	build.MustRun(goinstall)
 
-	// Put the default settings in.
-	gobuild.Args = append(gobuild.Args, buildFlags(env)...)
-
-	// We use -trimpath to avoid leaking local paths into the built executables.
-	gobuild.Args = append(gobuild.Args, "-trimpath")
-
-	// Show packages during build.
+	if cmds, err := ioutil.ReadDir("cmd"); err == nil {
+		for _, cmd := range cmds {
+			pkgs, err := parser.ParseDir(token.NewFileSet(), filepath.Join(".", "cmd", cmd.Name()), nil, parser.PackageClauseOnly)
+			if err != nil {
+				log.Fatal(err)
+			}
+			for name := range pkgs {
+				if name == "main" {
+					gobuild := goToolArch(*arch, *cc, "build", buildFlags(env)...)
 					gobuild.Args = append(gobuild.Args, "-v")
-
-	// Now we choose what we're even building.
-	// Default: collect all 'main' packages in cmd/ and build those.
-	packages := flag.Args()
-	if len(packages) == 0 {
-		packages = build.FindMainPackages("./cmd")
+					gobuild.Args = append(gobuild.Args, []string{"-o", executablePath(cmd.Name())}...)
+					gobuild.Args = append(gobuild.Args, "."+string(filepath.Separator)+filepath.Join("cmd", cmd.Name()))
+					build.MustRun(gobuild)
+					break
+				}
+			}
 		}
-
-	// Do the build!
-	for _, pkg := range packages {
-		args := make([]string, len(gobuild.Args))
-		copy(args, gobuild.Args)
-		args = append(args, "-o", executablePath(path.Base(pkg)))
-		args = append(args, pkg)
-		build.MustRun(&exec.Cmd{Path: gobuild.Path, Args: args, Env: gobuild.Env})
 	}
 }
 
-// buildFlags returns the go tool flags for building.
 func buildFlags(env build.Environment) (flags []string) {
 	var ld []string
 	if env.Commit != "" {
 		ld = append(ld, "-X", "main.gitCommit="+env.Commit)
-		ld = append(ld, "-X", "main.gitDate="+env.Date)
 	}
-	// Strip DWARF on darwin. This used to be required for certain things,
-	// and there is no downside to this, so we just keep doing it.
 	if runtime.GOOS == "darwin" {
 		ld = append(ld, "-s")
 	}
+
 	if len(ld) > 0 {
 		flags = append(flags, "-ldflags", strings.Join(ld, " "))
 	}
 	return flags
 }
 
-// goTool returns the go tool. This uses the Go version which runs ci.go.
 func goTool(subcmd string, args ...string) *exec.Cmd {
+	return goToolArch(runtime.GOARCH, os.Getenv("CC"), subcmd, args...)
+}
+
+func goToolArch(arch string, cc string, subcmd string, args ...string) *exec.Cmd {
 	cmd := build.GoTool(subcmd, args...)
-	goToolSetEnv(cmd)
-	return cmd
-}
-
-// localGoTool returns the go tool from the given GOROOT.
-func localGoTool(goroot string, subcmd string, args ...string) *exec.Cmd {
-	gotool := filepath.Join(goroot, "bin", "go")
-	cmd := exec.Command(gotool, subcmd)
-	goToolSetEnv(cmd)
-	cmd.Env = append(cmd.Env, "GOROOT="+goroot)
-	cmd.Args = append(cmd.Args, args...)
-	return cmd
-}
-
-// goToolSetEnv forwards the build environment to the go tool.
-func goToolSetEnv(cmd *exec.Cmd) {
+	cmd.Env = []string{"GOPATH=" + build.GOPATH()}
+	if arch == "" || arch == runtime.GOARCH {
 		cmd.Env = append(cmd.Env, "GOBIN="+GOBIN)
+	} else {
+		cmd.Env = append(cmd.Env, "CGO_ENABLED=1")
+		cmd.Env = append(cmd.Env, "GOARCH="+arch)
+	}
+	if cc != "" {
+		cmd.Env = append(cmd.Env, "CC="+cc)
+	}
 	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "GOBIN=") || strings.HasPrefix(e, "CC=") {
+		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") {
 			continue
 		}
 		cmd.Env = append(cmd.Env, e)
 	}
+	return cmd
 }
 
 // Running The Tests
@@ -335,7 +321,6 @@ func goToolSetEnv(cmd *exec.Cmd) {
 
 func doTest(cmdline []string) {
 	coverage := flag.Bool("coverage", false, "Whether to record code coverage")
-	verbose := flag.Bool("v", false, "Whether to log verbosely")
 	flag.CommandLine.Parse(cmdline)
 	env := build.Env()
 
@@ -343,55 +328,54 @@ func doTest(cmdline []string) {
 	if len(flag.CommandLine.Args()) > 0 {
 		packages = flag.CommandLine.Args()
 	}
+	packages = build.ExpandPackagesNoVendor(packages)
 
 	// Run the actual tests.
 	// Test a single package at a time. CI builders are slow
 	// and some tests run into timeouts under load.
 	gotest := goTool("test", buildFlags(env)...)
-	gotest.Args = append(gotest.Args, "-p", "1")
+	gotest.Args = append(gotest.Args, "-p", "1", "-timeout", "5m")
 	if *coverage {
 		gotest.Args = append(gotest.Args, "-covermode=atomic", "-cover")
 	}
-	if *verbose {
-		gotest.Args = append(gotest.Args, "-v")
-	}
 
 	gotest.Args = append(gotest.Args, packages...)
 	build.MustRun(gotest)
 }
 
-// doLint runs golangci-lint on requested packages.
+// runs gometalinter on requested packages
 func doLint(cmdline []string) {
-	var (
-		cachedir = flag.String("cachedir", "./build/cache", "directory for caching golangci-lint binary.")
-	)
 	flag.CommandLine.Parse(cmdline)
+
 	packages := []string{"./..."}
 	if len(flag.CommandLine.Args()) > 0 {
 		packages = flag.CommandLine.Args()
 	}
+	// Get metalinter and install all supported linters
+	build.MustRun(goTool("get", "gopkg.in/alecthomas/gometalinter.v2"))
+	build.MustRunCommand(filepath.Join(GOBIN, "gometalinter.v2"), "--install")
 
-	linter := downloadLinter(*cachedir)
-	lflags := []string{"run", "--config", ".golangci.yml"}
-	build.MustRunCommand(linter, append(lflags, packages...)...)
-	fmt.Println("You have achieved perfection.")
-}
-
-// downloadLinter downloads and unpacks golangci-lint.
-func downloadLinter(cachedir string) string {
-	const version = "1.27.0"
-
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	base := fmt.Sprintf("golangci-lint-%s-%s-%s", version, runtime.GOOS, runtime.GOARCH)
-	url := fmt.Sprintf("https://github.com/golangci/golangci-lint/releases/download/v%s/%s.tar.gz", version, base)
-	archivePath := filepath.Join(cachedir, base+".tar.gz")
-	if err := csdb.DownloadFile(url, archivePath); err != nil {
-		log.Fatal(err)
+	// Run fast linters batched together
+	configs := []string{
+		"--vendor",
+		"--tests",
+		"--deadline=2m",
+		"--disable-all",
+		"--enable=goimports",
+		"--enable=varcheck",
+		"--enable=vet",
+		"--enable=gofmt",
+		"--enable=misspell",
+		"--enable=goconst",
+		"--min-occurrences=6", // for goconst
 	}
-	if err := build.ExtractArchive(archivePath, cachedir); err != nil {
-		log.Fatal(err)
+	build.MustRunCommand(filepath.Join(GOBIN, "gometalinter.v2"), append(configs, packages...)...)
+
+	// Run slow linters one by one
+	for _, linter := range []string{"unconvert", "gosimple"} {
+		configs = []string{"--vendor", "--tests", "--deadline=10m", "--disable-all", "--enable=" + linter}
+		build.MustRunCommand(filepath.Join(GOBIN, "gometalinter.v2"), append(configs, packages...)...)
 	}
-	return filepath.Join(cachedir, base, "golangci-lint")
 }
 
 // Release Packaging
@@ -400,7 +384,6 @@ func doArchive(cmdline []string) {
 		arch   = flag.String("arch", runtime.GOARCH, "Architecture cross packaging")
 		atype  = flag.String("type", "zip", "Type of archive to write (zip|tar)")
 		signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. LINUX_SIGNING_KEY)`)
-		signify = flag.String("signify", "", `Environment variable holding the signify key (e.g. LINUX_SIGNIFY_KEY)`)
 		upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`)
 		ext    string
 	)
@@ -420,6 +403,9 @@ func doArchive(cmdline []string) {
 		basegeth = archiveBasename(*arch, params.ArchiveVersion(env.Commit))
 		geth     = "geth-" + basegeth + ext
 		alltools = "geth-alltools-" + basegeth + ext
+
+		baseswarm = archiveBasename(*arch, sv.ArchiveVersion(env.Commit))
+		swarm     = "swarm-" + baseswarm + ext
 	)
 	maybeSkipArchive(env)
 	if err := build.WriteArchive(geth, gethArchiveFiles); err != nil {
@@ -428,8 +414,11 @@ func doArchive(cmdline []string) {
 	if err := build.WriteArchive(alltools, allToolsArchiveFiles); err != nil {
 		log.Fatal(err)
 	}
-	for _, archive := range []string{geth, alltools} {
-		if err := archiveUpload(archive, *upload, *signer, *signify); err != nil {
+	if err := build.WriteArchive(swarm, swarmArchiveFiles); err != nil {
+		log.Fatal(err)
+	}
+	for _, archive := range []string{geth, alltools, swarm} {
+		if err := archiveUpload(archive, *upload, *signer); err != nil {
 			log.Fatal(err)
 		}
 	}
@@ -449,7 +438,7 @@ func archiveBasename(arch string, archiveVersion string) string {
 	return platform + "-" + archiveVersion
 }
 
-func archiveUpload(archive string, blobstore string, signer string, signifyVar string) error {
+func archiveUpload(archive string, blobstore string, signer string) error {
 	// If signing was requested, generate the signature files
 	if signer != "" {
 		key := getenvBase64(signer)
@@ -457,14 +446,6 @@ func archiveUpload(archive string, blobstore string, signer string, signifyVar s
 			return err
 		}
 	}
-	if signifyVar != "" {
-		key := os.Getenv(signifyVar)
-		untrustedComment := "verify with geth-release.pub"
-		trustedComment := fmt.Sprintf("%s (%s)", archive, time.Now().UTC().Format(time.RFC1123))
-		if err := signify.SignFile(archive, archive+".sig", key, untrustedComment, trustedComment); err != nil {
-			return err
-		}
-	}
 	// If uploading to Azure was requested, push the archive possibly with its signature
 	if blobstore != "" {
 		auth := build.AzureBlobstoreConfig{
@@ -480,11 +461,6 @@ func archiveUpload(archive string, blobstore string, signer string, signifyVar s
 				return err
 			}
 		}
-		if signifyVar != "" {
-			if err := build.AzureBlobstoreUpload(archive+".sig", filepath.Base(archive+".sig"), auth); err != nil {
-				return err
-			}
-		}
 	}
 	return nil
 }
@@ -508,7 +484,6 @@ func maybeSkipArchive(env build.Environment) {
 // Debian Packaging
 func doDebianSource(cmdline []string) {
 	var (
-		cachedir = flag.String("cachedir", "./build/cache", `Filesystem path to cache the downloaded Go bundles at`)
 		signer  = flag.String("signer", "", `Signing key name, also used as package author`)
 		upload  = flag.String("upload", "", `Where to upload the source package (usually "ethereum/ethereum")`)
 		sshUser = flag.String("sftp-user", "", `Username for SFTP upload (usually "geth-ci")`)
@@ -527,39 +502,12 @@ func doDebianSource(cmdline []string) {
 		build.MustRun(gpg)
 	}
 
-	// Download and verify the Go source package.
-	gobundle := downloadGoSources(*cachedir)
-
-	// Download all the dependencies needed to build the sources and run the ci script
-	srcdepfetch := goTool("mod", "download")
-	srcdepfetch.Env = append(os.Environ(), "GOPATH="+filepath.Join(*workdir, "modgopath"))
-	build.MustRun(srcdepfetch)
-
-	cidepfetch := goTool("run", "./build/ci.go")
-	cidepfetch.Env = append(os.Environ(), "GOPATH="+filepath.Join(*workdir, "modgopath"))
-	cidepfetch.Run() // Command fails, don't care, we only need the deps to start it
-
-	// Create Debian packages and upload them.
+	// Create Debian packages and upload them
 	for _, pkg := range debPackages {
-		for distro, goboot := range debDistroGoBoots {
-			// Prepare the debian package with the go-ethereum sources.
-			meta := newDebMetadata(distro, goboot, *signer, env, now, pkg.Name, pkg.Version, pkg.Executables)
+		for _, distro := range debDistros {
+			meta := newDebMetadata(distro, *signer, env, now, pkg.Name, pkg.Version, pkg.Executables)
 			pkgdir := stageDebianSource(*workdir, meta)
-
-			// Add Go source code
-			if err := build.ExtractArchive(gobundle, pkgdir); err != nil {
-				log.Fatalf("Failed to extract Go sources: %v", err)
-			}
-			if err := os.Rename(filepath.Join(pkgdir, "go"), filepath.Join(pkgdir, ".go")); err != nil {
-				log.Fatalf("Failed to rename Go source folder: %v", err)
-			}
-			// Add all dependency modules in compressed form
-			os.MkdirAll(filepath.Join(pkgdir, ".mod", "cache"), 0755)
-			if err := cp.CopyAll(filepath.Join(pkgdir, ".mod", "cache", "download"), filepath.Join(*workdir, "modgopath", "pkg", "mod", "cache", "download")); err != nil {
-				log.Fatalf("Failed to copy Go module dependencies: %v", err)
-			}
-			// Run the packaging and upload to the PPA
-			debuild := exec.Command("debuild", "-S", "-sa", "-us", "-uc", "-d", "-Zxz", "-nc")
+			debuild := exec.Command("debuild", "-S", "-sa", "-us", "-uc", "-d", "-Zxz")
 			debuild.Dir = pkgdir
 			build.MustRun(debuild)
 
@@ -579,53 +527,6 @@ func doDebianSource(cmdline []string) {
 	}
 }
 
-// downloadGoSources downloads the Go source tarball.
-func downloadGoSources(cachedir string) string {
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	file := fmt.Sprintf("go%s.src.tar.gz", dlgoVersion)
-	url := "https://dl.google.com/go/" + file
-	dst := filepath.Join(cachedir, file)
-	if err := csdb.DownloadFile(url, dst); err != nil {
-		log.Fatal(err)
-	}
-	return dst
-}
-
-// downloadGo downloads the Go binary distribution and unpacks it into a temporary
-// directory. It returns the GOROOT of the unpacked toolchain.
-func downloadGo(goarch, goos, cachedir string) string {
-	if goarch == "arm" {
-		goarch = "armv6l"
-	}
-
-	csdb := build.MustLoadChecksums("build/checksums.txt")
-	file := fmt.Sprintf("go%s.%s-%s", dlgoVersion, goos, goarch)
-	if goos == "windows" {
-		file += ".zip"
-	} else {
-		file += ".tar.gz"
-	}
-	url := "https://golang.org/dl/" + file
-	dst := filepath.Join(cachedir, file)
-	if err := csdb.DownloadFile(url, dst); err != nil {
-		log.Fatal(err)
-	}
-
-	ucache, err := os.UserCacheDir()
-	if err != nil {
-		log.Fatal(err)
-	}
-	godir := filepath.Join(ucache, fmt.Sprintf("geth-go-%s-%s-%s", dlgoVersion, goos, goarch))
-	if err := build.ExtractArchive(dst, godir); err != nil {
-		log.Fatal(err)
-	}
-	goroot, err := filepath.Abs(filepath.Join(godir, "go"))
-	if err != nil {
-		log.Fatal(err)
-	}
-	return goroot
-}
-
 func ppaUpload(workdir, ppa, sshUser string, files []string) {
 	p := strings.Split(ppa, "/")
 	if len(p) != 2 {
@@ -679,15 +580,13 @@ func isUnstableBuild(env build.Environment) bool {
 }
 
 type debPackage struct {
-	Name        string          // the name of the Debian package to produce, e.g. "ethereum"
-	Version     string          // the clean version of the debPackage, e.g. 1.8.12, without any metadata
+	Name        string          // the name of the Debian package to produce, e.g. "ethereum", or "ethereum-swarm"
+	Version     string          // the clean version of the debPackage, e.g. 1.8.12 or 0.3.0, without any metadata
 	Executables []debExecutable // executables to be included in the package
 }
 
 type debMetadata struct {
 	Env build.Environment
-	GoBootPackage string
-	GoBootPath    string
 
 	PackageName string
 
@@ -716,14 +615,12 @@ func (d debExecutable) Package() string {
 	return d.BinaryName
 }
 
-func newDebMetadata(distro, goboot, author string, env build.Environment, t time.Time, name string, version string, exes []debExecutable) debMetadata {
+func newDebMetadata(distro, author string, env build.Environment, t time.Time, name string, version string, exes []debExecutable) debMetadata {
 	if author == "" {
 		// No signing key, use default author.
 		author = "Ethereum Builds <fjl@ethereum.org>"
 	}
 	return debMetadata{
-		GoBootPackage: goboot,
-		GoBootPath:    debGoBootPaths[goboot],
 		PackageName: name,
 		Env:         env,
 		Author:      author,
@@ -795,6 +692,7 @@ func stageDebianSource(tmpdir string, meta debMetadata) (pkgdir string) {
 	if err := os.Mkdir(pkgdir, 0755); err != nil {
 		log.Fatal(err)
 	}
+
 	// Copy the source code.
 	build.MustRunCommand("git", "checkout-index", "-a", "--prefix", pkgdir+string(filepath.Separator))
 
@@ -812,6 +710,7 @@ func stageDebianSource(tmpdir string, meta debMetadata) (pkgdir string) {
 		build.Render("build/deb/"+meta.PackageName+"/deb.install", install, 0644, exe)
 		build.Render("build/deb/"+meta.PackageName+"/deb.docs", docs, 0644, exe)
 	}
+
 	return pkgdir
 }
 
@@ -821,7 +720,6 @@ func doWindowsInstaller(cmdline []string) {
 	var (
 		arch    = flag.String("arch", runtime.GOARCH, "Architecture for cross build packaging")
 		signer  = flag.String("signer", "", `Environment variable holding the signing key (e.g. WINDOWS_SIGNING_KEY)`)
-		signify = flag.String("signify key", "", `Environment variable holding the signify signing key (e.g. WINDOWS_SIGNIFY_KEY)`)
 		upload  = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`)
 		workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`)
 	)
@@ -860,12 +758,9 @@ func doWindowsInstaller(cmdline []string) {
 	build.Render("build/nsis.uninstall.nsh", filepath.Join(*workdir, "uninstall.nsh"), 0644, allTools)
 	build.Render("build/nsis.pathupdate.nsh", filepath.Join(*workdir, "PathUpdate.nsh"), 0644, nil)
 	build.Render("build/nsis.envvarupdate.nsh", filepath.Join(*workdir, "EnvVarUpdate.nsh"), 0644, nil)
-	if err := cp.CopyFile(filepath.Join(*workdir, "SimpleFC.dll"), "build/nsis.simplefc.dll"); err != nil {
-		log.Fatal("Failed to copy SimpleFC.dll: %v", err)
-	}
-	if err := cp.CopyFile(filepath.Join(*workdir, "COPYING"), "COPYING"); err != nil {
-		log.Fatal("Failed to copy copyright note: %v", err)
-	}
+	build.CopyFile(filepath.Join(*workdir, "SimpleFC.dll"), "build/nsis.simplefc.dll", 0755)
+	build.CopyFile(filepath.Join(*workdir, "COPYING"), "COPYING", 0755)
+
 	// Build the installer. This assumes that all the needed files have been previously
 	// built (don't mix building and packaging to keep cross compilation complexity to a
 	// minimum).
@@ -882,8 +777,9 @@ func doWindowsInstaller(cmdline []string) {
 		"/DARCH="+*arch,
 		filepath.Join(*workdir, "geth.nsi"),
 	)
+
 	// Sign and publish installer.
-	if err := archiveUpload(installer, *upload, *signer, *signify); err != nil {
+	if err := archiveUpload(installer, *upload, *signer); err != nil {
 		log.Fatal(err)
 	}
 }
@@ -894,7 +790,6 @@ func doAndroidArchive(cmdline []string) {
 	var (
 		local  = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`)
 		signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. ANDROID_SIGNING_KEY)`)
-		signify = flag.String("signify", "", `Environment variable holding the signify signing key (e.g. ANDROID_SIGNIFY_KEY)`)
 		deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "https://oss.sonatype.org")`)
 		upload = flag.String("upload", "", `Destination to upload the archive (usually "gethstore/builds")`)
 	)
@@ -905,14 +800,17 @@ func doAndroidArchive(cmdline []string) {
 	if os.Getenv("ANDROID_HOME") == "" {
 		log.Fatal("Please ensure ANDROID_HOME points to your Android SDK")
 	}
+	if os.Getenv("ANDROID_NDK") == "" {
+		log.Fatal("Please ensure ANDROID_NDK points to your Android NDK")
+	}
 	// Build the Android archive and Maven resources
 	build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile", "golang.org/x/mobile/cmd/gobind"))
+	build.MustRun(gomobileTool("init", "--ndk", os.Getenv("ANDROID_NDK")))
 	build.MustRun(gomobileTool("bind", "-ldflags", "-s -w", "--target", "android", "--javapkg", "org.ethereum", "-v", "github.com/ethereum/go-ethereum/mobile"))
 
 	if *local {
 		// If we're building locally, copy bundle to build dir and skip Maven
 		os.Rename("geth.aar", filepath.Join(GOBIN, "geth.aar"))
-		os.Rename("geth-sources.jar", filepath.Join(GOBIN, "geth-sources.jar"))
 		return
 	}
 	meta := newMavenMetadata(env)
@@ -925,7 +823,7 @@ func doAndroidArchive(cmdline []string) {
 	archive := "geth-" + archiveBasename("android", params.ArchiveVersion(env.Commit)) + ".aar"
 	os.Rename("geth.aar", archive)
 
-	if err := archiveUpload(archive, *upload, *signer, *signify); err != nil {
+	if err := archiveUpload(archive, *upload, *signer); err != nil {
 		log.Fatal(err)
 	}
 	// Sign and upload all the artifacts to Maven Central
@@ -956,15 +854,15 @@ func gomobileTool(subcmd string, args ...string) *exec.Cmd {
 	cmd := exec.Command(filepath.Join(GOBIN, "gomobile"), subcmd)
 	cmd.Args = append(cmd.Args, args...)
 	cmd.Env = []string{
+		"GOPATH=" + build.GOPATH(),
 		"PATH=" + GOBIN + string(os.PathListSeparator) + os.Getenv("PATH"),
 	}
 	for _, e := range os.Environ() {
-		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "PATH=") || strings.HasPrefix(e, "GOBIN=") {
+		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "PATH=") {
 			continue
 		}
 		cmd.Env = append(cmd.Env, e)
 	}
-	cmd.Env = append(cmd.Env, "GOBIN="+GOBIN)
 	return cmd
 }
 
@@ -1020,7 +918,6 @@ func doXCodeFramework(cmdline []string) {
 	var (
 		local  = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`)
 		signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. IOS_SIGNING_KEY)`)
-		signify = flag.String("signify", "", `Environment variable holding the signify signing key (e.g. IOS_SIGNIFY_KEY)`)
 		deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "trunk")`)
 		upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`)
 	)
@@ -1030,11 +927,11 @@ func doXCodeFramework(cmdline []string) {
 	// Build the iOS XCode framework
 	build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile", "golang.org/x/mobile/cmd/gobind"))
 	build.MustRun(gomobileTool("init"))
-	bind := gomobileTool("bind", "-ldflags", "-s -w", "--target", "ios", "-v", "github.com/ethereum/go-ethereum/mobile")
+	bind := gomobileTool("bind", "-ldflags", "-s -w", "--target", "ios", "--tags", "ios", "-v", "github.com/ethereum/go-ethereum/mobile")
 
 	if *local {
 		// If we're building locally, use the build folder and stop afterwards
-		bind.Dir = GOBIN
+		bind.Dir, _ = filepath.Abs(GOBIN)
 		build.MustRun(bind)
 		return
 	}
@@ -1050,14 +947,14 @@ func doXCodeFramework(cmdline []string) {
 	maybeSkipArchive(env)
 
 	// Sign and upload the framework to Azure
-	if err := archiveUpload(archive+".tar.gz", *upload, *signer, *signify); err != nil {
+	if err := archiveUpload(archive+".tar.gz", *upload, *signer); err != nil {
 		log.Fatal(err)
 	}
 	// Prepare and upload a PodSpec to CocoaPods
 	if *deploy != "" {
 		meta := newPodMetadata(env, archive)
 		build.Render("build/pod.podspec", "Geth.podspec", 0755, meta)
-		build.MustRunCommand("pod", *deploy, "push", "Geth.podspec", "--allow-warnings")
+		build.MustRunCommand("pod", *deploy, "push", "Geth.podspec", "--allow-warnings", "--verbose")
 	}
 }
 
@@ -1124,7 +1021,7 @@ func doXgo(cmdline []string) {
 
 	if *alltools {
 		args = append(args, []string{"--dest", GOBIN}...)
-		for _, res := range allToolsArchiveFiles {
+		for _, res := range allCrossCompiledArchiveFiles {
 			if strings.HasPrefix(res, GOBIN) {
 				// Binary tool found, cross build it explicitly
 				args = append(args, "./"+filepath.Join("cmd", filepath.Base(res)))
@@ -1145,10 +1042,16 @@ func doXgo(cmdline []string) {
 
 func xgoTool(args []string) *exec.Cmd {
 	cmd := exec.Command(filepath.Join(GOBIN, "xgo"), args...)
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, []string{
+	cmd.Env = []string{
+		"GOPATH=" + build.GOPATH(),
 		"GOBIN=" + GOBIN,
-	}...)
+	}
+	for _, e := range os.Environ() {
+		if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") {
+			continue
+		}
+		cmd.Env = append(cmd.Env, e)
+	}
 	return cmd
 }
 
@@ -1175,8 +1078,6 @@ func doPurge(cmdline []string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("Found %d blobs\n", len(blobs))
-
 	// Iterate over the blobs, collect and sort all unstable builds
 	for i := 0; i < len(blobs); i++ {
 		if !strings.Contains(blobs[i].Name, "unstable") {
@@ -1198,7 +1099,6 @@ func doPurge(cmdline []string) {
 			break
 		}
 	}
-	fmt.Printf("Deleting %d blobs\n", len(blobs))
 	// Delete all marked as such and return
 	if err := build.AzureBlobstoreDelete(auth, blobs); err != nil {
 		log.Fatal(err)

build/clean_go_build_cache.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+# Cleaning the Go cache only makes sense if we actually have Go installed... or
+# if Go is actually callable. This does not hold true during deb packaging, so
+# we need an explicit check to avoid build failures.
+if ! command -v go > /dev/null; then
+  exit
+fi
+
+version_gt() {
+  test "$(printf '%s\n' "$@" | sort -V | head -n 1)" != "$1"
+}
+
+golang_version=$(go version |cut -d' ' -f3 |sed 's/go//')
+
+# Clean go build cache when go version is greater than or equal to 1.10
+if !(version_gt 1.10 $golang_version); then
+    go clean -cache
+fi

build/deb/ethereum-swarm/deb.changelog

@@ -0,0 +1,5 @@
+{{.Name}} ({{.VersionString}}) {{.Distro}}; urgency=low
+
+  * git build of {{.Env.Commit}}
+
+ -- {{.Author}}  {{.Time}}