.gitmodules

@@ -1,8 +1,3 @@
 [submodule "tests"]
 	path = tests/testdata
 	url = https://github.com/ethereum/tests
-	shallow = true
-[submodule "evm-benchmarks"]
-	path = tests/evm-benchmarks
-	url = https://github.com/ipsilon/evm-benchmarks
-	shallow = true

.golangci.yml

@@ -1,7 +1,7 @@
 # This file configures github.com/golangci/golangci-lint.
 
 run:
-  timeout: 20m
+  timeout: 3m
   tests: true
   # default is true. Enables skipping of directories:
   #   vendor$, third_party$, testdata$, examples$, Godeps$, builtin$

.travis.yml

@@ -5,7 +5,7 @@ jobs:
   allow_failures:
     - stage: build
       os: osx
-      go: 1.17.x
+      go: 1.15.x
       env:
         - azure-osx
         - azure-ios
@@ -16,7 +16,7 @@ jobs:
     - stage: lint
       os: linux
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - lint
       git:
@@ -31,7 +31,7 @@ jobs:
       os: linux
       arch: amd64
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - docker
       services:
@@ -48,7 +48,7 @@ jobs:
       os: linux
       arch: arm64
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - docker
       services:
@@ -65,7 +65,7 @@ jobs:
       if: type = push
       os: linux
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - ubuntu-ppa
         - GO111MODULE=on
@@ -90,7 +90,7 @@ jobs:
       os: linux
       dist: bionic
       sudo: required
-      go: 1.18.x
+      go: 1.16.x
       env:
         - azure-linux
         - GO111MODULE=on
@@ -120,6 +120,36 @@ jobs:
         - 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
 
+    # This builder does the Linux Azure MIPS xgo uploads
+    - stage: build
+      if: type = push
+      os: linux
+      dist: bionic
+      services:
+        - docker
+      go: 1.16.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 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 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 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
+
     # This builder does the Android Maven and Azure uploads
     - stage: build
       if: type = push
@@ -148,7 +178,7 @@ jobs:
         - 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.18.linux-amd64.tar.gz | tar -xz
+        - curl https://dl.google.com/go/go1.16.linux-amd64.tar.gz | tar -xz
         - export PATH=`pwd`/go/bin:$PATH
         - export GOROOT=`pwd`/go
         - export GOPATH=$HOME/go
@@ -162,7 +192,7 @@ jobs:
     - stage: build
       if: type = push
       os: osx
-      go: 1.18.x
+      go: 1.16.x
       env:
         - azure-osx
         - azure-ios
@@ -194,7 +224,7 @@ jobs:
       os: linux
       arch: amd64
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - GO111MODULE=on
       script:
@@ -205,7 +235,7 @@ jobs:
       os: linux
       arch: arm64
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - GO111MODULE=on
       script:
@@ -214,7 +244,7 @@ jobs:
     - stage: build
       os: linux
       dist: bionic
-      go: 1.17.x
+      go: 1.15.x
       env:
         - GO111MODULE=on
       script:
@@ -225,7 +255,7 @@ jobs:
       if: type = cron
       os: linux
       dist: bionic
-      go: 1.18.x
+      go: 1.16.x
       env:
         - azure-purge
         - GO111MODULE=on
@@ -233,15 +263,3 @@ jobs:
         submodules: false # avoid cloning ethereum/tests
       script:
         - go run build/ci.go purge -store gethstore/builds -days 14
-
-    # This builder executes race tests
-    - stage: build
-      if: type = cron
-      os: linux
-      dist: bionic
-      go: 1.18.x
-      env:
-        - GO111MODULE=on
-      script:
-        - go run build/ci.go test  -race -coverage $TEST_PACKAGES
-

Dockerfile

@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""
 
 # Build Geth in a stock Go builder container
-FROM golang:1.18-alpine as builder
+FROM golang:1.16-alpine as builder
 
 RUN apk add --no-cache gcc musl-dev linux-headers git
 

Dockerfile.alltools

@@ -4,7 +4,7 @@ ARG VERSION=""
 ARG BUILDNUM=""
 
 # Build Geth in a stock Go builder container
-FROM golang:1.18-alpine as builder
+FROM golang:1.16-alpine as builder
 
 RUN apk add --no-cache gcc musl-dev linux-headers git
 

Makefile

@@ -2,7 +2,11 @@
 # with Go source code. If you know what GOPATH is then you probably
 # don't need to bother with make.
 
-.PHONY: geth android ios evm all test clean
+.PHONY: geth android ios geth-cross evm all test clean
+.PHONY: geth-linux geth-linux-386 geth-linux-amd64 geth-linux-mips64 geth-linux-mips64le
+.PHONY: geth-linux-arm geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64
+.PHONY: geth-darwin geth-darwin-386 geth-darwin-amd64
+.PHONY: geth-windows geth-windows-386 geth-windows-amd64
 
 GOBIN = ./build/bin
 GO ?= latest
@@ -49,3 +53,95 @@ devtools:
 	env GOBIN= go install ./cmd/abigen
 	@type "solc" 2> /dev/null || echo 'Please install solc'
 	@type "protoc" 2> /dev/null || echo 'Please install protoc'
+
+# Cross Compilation Targets (xgo)
+
+geth-cross: geth-linux geth-darwin geth-windows geth-android geth-ios
+	@echo "Full cross compilation done:"
+	@ls -ld $(GOBIN)/geth-*
+
+geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm geth-linux-mips64 geth-linux-mips64le
+	@echo "Linux cross compilation done:"
+	@ls -ld $(GOBIN)/geth-linux-*
+
+geth-linux-386:
+	$(GORUN) 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
+	@echo "Linux amd64 cross compilation done:"
+	@ls -ld $(GOBIN)/geth-linux-* | grep amd64
+
+geth-linux-arm: geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64
+	@echo "Linux ARM cross compilation done:"
+	@ls -ld $(GOBIN)/geth-linux-* | grep arm
+
+geth-linux-arm-5:
+	$(GORUN) 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
+	@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
+	@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
+	@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
+	@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
+	@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
+	@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
+	@echo "Linux MIPS64le cross compilation done:"
+	@ls -ld $(GOBIN)/geth-linux-* | grep mips64le
+
+geth-darwin: geth-darwin-386 geth-darwin-amd64
+	@echo "Darwin cross compilation done:"
+	@ls -ld $(GOBIN)/geth-darwin-*
+
+geth-darwin-386:
+	$(GORUN) 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
+	@echo "Darwin amd64 cross compilation done:"
+	@ls -ld $(GOBIN)/geth-darwin-* | grep amd64
+
+geth-windows: geth-windows-386 geth-windows-amd64
+	@echo "Windows cross compilation done:"
+	@ls -ld $(GOBIN)/geth-windows-*
+
+geth-windows-386:
+	$(GORUN) 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
+	@echo "Windows amd64 cross compilation done:"
+	@ls -ld $(GOBIN)/geth-windows-* | grep amd64

README.md

@@ -52,28 +52,12 @@ Going through all the possible command line flags is out of scope here (please c
 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.
 
-### Hardware Requirements
-
-Minimum:
-
-* CPU with 2+ cores
-* 4GB RAM
-* 1TB free storage space to sync the Mainnet
-* 8 MBit/sec download Internet service
-
-Recommended:
-
-* Fast CPU with 4+ cores
-* 16GB+ RAM
-* High Performance SSD with at least 1TB free space
-* 25+ MBit/sec download Internet service
-
 ### 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
-sync quickly to the current state of the network. To do so:
+fast-sync quickly to the current state of the network. To do so:
 
 ```shell
 $ geth console
@@ -84,7 +68,7 @@ This command will:
    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 interact using [`web3` methods](https://github.com/ChainSafe/web3.js/blob/0.20.7/DOCUMENTATION.md) 
+   (via the trailing `console` subcommand) through which you can interact using [`web3` methods](https://web3js.readthedocs.io/en/) 
    (note: the `web3` version bundled within `geth` is very old, and not up to date with official docs),
    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
@@ -175,13 +159,13 @@ docker run -d --name ethereum-node -v /Users/alice/ethereum:/root \
            ethereum/client-go
 ```
 
-This will start `geth` in snap-sync mode with a DB memory allowance of 1GB just as the
+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 are not
+and/or hosts. By default, `geth` binds to the local interface and RPC endpoints is not
 accessible from the outside.
 
 ### Programmatically interfacing `geth` nodes
@@ -247,8 +231,7 @@ aware of and agree upon. This consists of a small JSON file (e.g. call it `genes
     "constantinopleBlock": 0,
     "petersburgBlock": 0,
     "istanbulBlock": 0,
-    "berlinBlock": 0,
+    "berlinBlock": 0
-    "londonBlock": 0
   },
   "alloc": {},
   "coinbase": "0x0000000000000000000000000000000000000000",

SECURITY.md

@@ -12,14 +12,12 @@ Audit reports are published in the `docs` folder: https://github.com/ethereum/go
 | ------- | ------- | ----------- |
 | `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) |
-| `Discv5` | 20191015 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2019-10-15_Discv5_audit_LeastAuthority.pdf) |
-| `Discv5` | 20200124 | [pdf](https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2020-01-24_DiscV5_audit_Cure53.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 publicly disclosed security vulnerabilities.
+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.
 
@@ -29,147 +27,92 @@ Fingerprint: `AE96 ED96 9E47 9B00 84F3 E17F E88D 3334 FA5F 6A0A`
 
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----
-Version: SKS 1.1.6
+Version: GnuPG v1
-Comment: Hostname: pgp.mit.edu
 
-mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaYneAk3Bp1
+mQINBFgl3tgBEAC8A1tUBkD9YV+eLrOmtgy+/JS/H9RoZvkg3K1WZ8IYfj6iIRaY
-82GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9L8c8yiqry1ZTCmYM
+neAk3Bp182GUPVz/zhKr2g0tMXIScDR3EnaDsY+Qg+JqQl8NOG+Cikr1nnkG2on9
-qCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUim+y7buJDtoNf7YILlhDQXN8q
+L8c8yiqry1ZTCmYMqCa2acTFqnyuXJ482aZNtB4QG2BpzfhW4k8YThpegk/EoRUi
-lHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0bfUo9pexOn7LS4SojoJmsm/5dp6AoKlac
+m+y7buJDtoNf7YILlhDQXN8qlHB02DWOVUihph9tUIFsPK6BvTr9SIr/eG6j6k0b
-48cZU5zwR9AYcq/nvkrfmf2WkObg/xRdEvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/y
+fUo9pexOn7LS4SojoJmsm/5dp6AoKlac48cZU5zwR9AYcq/nvkrfmf2WkObg/xRd
-PFE335k+ujjZCPOu7OwjzDk7M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXCho
+EvKZzn05jRopmAIwmoC3CiLmqCHPmT5a29vEob/yPFE335k+ujjZCPOu7OwjzDk7
-yI8vbfp4dGvCvYqvQAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+F
+M0zMSfnNfDq8bXh16nn+ueBxJ0NzgD1oC6c2PhM+XRQCXChoyI8vbfp4dGvCvYqv
-nQOUgg2Hh8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
+QAE1bWjqnumZ/7vUPgZN6gDfiAzG2mUxC2SeFBhacgzDvtQls+uuvm+FnQOUgg2H
-2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZEZCjMXxB
+h8x2zgoZ7kqV29wjaUPFREuew7e+Th5BxielnzOfVycVXeSuvvIn6cd3g/s8mX1c
-8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQABtDRFdGhlcmV1bSBG
+2kLSXJR7+KdWDrIrR5Az0kwAqFZt6B6QTlDrPswu3mxsm5TzMbny0PsbL/HBM+GZ
-b3VuZGF0aW9uIEJ1ZyBCb3VudHkgPGJvdW50eUBldGhlcmV1bS5vcmc+iQIcBBEBCAAGBQJa
+EZCjMXxB8bqV2eSaktjnSlUNX1VXxyOxXA+ZG2jwpr51egi57riVRXokrQARAQAB
-FCY6AAoJEHoMA3Q0/nfveH8P+gJBPo9BXZL8isUfbUWjwLi81Yi70hZqIJUnz64SWTqBzg5b
+tDlFdGhlcmV1bSBGb3VuZGF0aW9uIFNlY3VyaXR5IFRlYW0gPHNlY3VyaXR5QGV0
-mCZ69Ji5637THsxQetS2ARabz0DybQ779FhD/IWnqV9T3KuBM/9RzJtuhLzKCyMrAINPMo28
+aGVyZXVtLm9yZz6JAj4EEwECACgCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheA
-rKWdunHHarpuR4m3tL2zWJkle5QVYb+vkZXJJE98PJw+N4IYeKKeCs2ubeqZu636GA0sMzzB
+BQJaCWH6BQkFo2BYAAoJEOiNMzT6X2oK+DEP/3H6dxkm0hvHZKoHLVuuxcu3EHYo
-Jn3m/dRRA2va+/zzbr6F6b51ynzbMxWKTsJnstjC8gs8EeI+Zcd6otSyelLtCUkk3h5sTvpV
+k5sd3MMWPrZSN8qzZnY7ayEDMxnarWOizc+2jfOxfJlzX/g8lR1/fsHdWPFPhPoV
-Wv67BNSU0BYsMkxyFi9PUyy07Wixgeas89K5jG1oOtDva/FkpRHrTE/WA5OXDRcLrHJM+SwD
+Qk8ygrHn1H8U8+rpw/U03BqmqHpYCDzJ+CIis9UWROniqXw1nuqu/FtWOsdWxNKh
-CwqcLQqJd09NxwUW1iKeBmPptTiOGu1Gv2o7aEyoaWrHRBO7JuYrQrj6q2B3H1Je0zjAd2qt
+jUo6k/0EsaXsxRPzgJv7fEUcVcQ7as/C3x9sy3muc2gvgA4/BKoGPb1/U0GuA8lV
-09ni2bLwLn4LA+VDpprNTO+eZDprv09s2oFSU6NwziHybovu0y7X4pADGkK2evOM7c86PohX
+fDIDshAggmnSUAg+TuYSAAdoFQ1sKwFMPigcLJF2eyKuK3iUyixJrec/c4LSf3wA
-QRQ1M1T16xLj6wP8/Ykwl6v/LUk7iDPXP3GPILnh4YOkwBR3DsCOPn8098xy7FxEELmupRzt
+cGghbeuqI8INP0Y2zvXDQN2cByxsFAuoZG+m0cyKGaDH2MVUvOKKYqn/03qvrf15
-Cj9oC7YAoweeShgUjBPzb+nGY1m6OcFfbUPBgFyMMfwF6joHbiVIO+39+Ut2g2ysZa7KF+yp
+AWAsW0l0yQwOTCo3FbsNzemClm5Bj/xH0E4XuwXwChcMCMOWJrFoxyvCEI+keoQc
-XqVDqyEkYXsOLb25OC7brt8IJEPgBPwcHK5GNag6RfLxnQV+iVZ9KNH1yQgSiQI+BBMBAgAo
+c08/a8/MtS7vBAABXwOziSmm6CNqmzpWrh/fDrjlJlba9U3MxzvqU3IFlTdMratv
-AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAUCWglh+gUJBaNgWAAKCRDojTM0+l9qCgQ2
+6V+SgX+L25lCzW4NxxUavoB8fAlvo8lxpHKo24FP+RcLQ8XqkU3RiUsgRjQRFOqQ
-D/4udJpV4zGIZW1yNaVvtd3vfKsTLi7GIRJLUBqVb2Yx/uhnN8jTl/tAhCVosCQ1pzvi9kMl
+TaJcsp8mimmiYyf24mNu6b48pi+a5c/eQR9w59emeEUZqsJU+nqv8BWIIp7o4Agh
-s8qO1vu2kw5EWFFkwK96roI8pTql3VIjwhRVQrCkR7oAk/eUd1U/nt2q6J4UTYeVgqbq4dsI
+NYnKjkhPlY5e1fLVfAHIADZFynWwRPkPMJSrBiP5EtcOFxQGHGjRxU/KjXkvE0hV
-ZZTRyPJMD667YpuAIcaah+w9j/E5xksYQdMeprnDrQkkBCb4FIMqfDzBPKvEa8DcQr949K85
+xYb1PB8pWMTu/beeiQI+BBMBAgAoBQJYJd7YAhsDBQkB4TOABgsJCAcDAgYVCAIJ
-kxhr6LDq9i5l4Egxt2JdH8DaR4GLca6+oHy0MyPs/bZOsfmZUObfM2oZgPpqYM96JanhzO1j
+CgsEFgIDAQIeAQIXgAAKCRDojTM0+l9qCplDD/9IZ2i+m1cnqQKtiyHbyFGx32oL
-dpnItyBii2pc+kNx5nMOf4eikE/MBv+WUJ0TttWzApGGmFUzDhtuEvRH9NBjtJ/pMrYspIGu
+fzqPylX2bOG5DPsSTorSUdJMGVfT04oVxXc4S/2DVnNvi7RAbSiLapCWSplgtBOj
-O/QNY5KKOKQTvVIlwGcm8dTsSkqtBDSUwZyWbfKfKOI1/RhM9dC3gj5/BOY57DYYV4rdTK01
+j1xlblOoXxT3m7s1XHGCX5tENxI9fVSSPVKJn+fQaWpPB2MhBA+1lUI6GJ+11T7K
-ZtYjuhdfs2bhuP1uF/cgnSSZlv8azvf7Egh7tHPnYxvLjfq1bJAhCIX0hNg0a81/ndPAEFky
+J8LrP/fiw1/nOb7rW61HW44Gtyox23sA/d1+DsFVaF8hxJlNj5coPKr8xWzQ8pQl
-fSko+JPKvdSvsUcSi2QQ4U2HX//jNBjXRfG4F0utgbJnhXzEckz6gqt7wSDZH2oddVuO8Ssc
+juzdjHDukjevuw4rRmRq9vozvj9keEU9XJ5dldyEVXFmdDk7KT0p0Rla9nxYhzf/
-T7sK+CdXthSKnRyuI+sGUpG+6glpKWIfYkWFKNZWuQ+YUatY3QEDHXTIioycSmV8p4d/g/0S
+r/Bv8Bzy0HCWRb2D31BjXXGG05oVnYmNGxGFxYja4MwgrMmne3ilEVjfUJsapsqi
-V6TegidLxY8bXMkbqz+3n6FArRffv5MH7qt3cYkCPgQTAQIAKAUCWCXhOwIbAwUJAeEzgAYL
+w41BAyQgIdfREulYN7ahsF5PrjVAqBd9IGtE8ULelF2SQxEBQBngEkP0ahP6tRAL
-CQgHAwIGFQgCCQoLBBYCAwECHgECF4AACgkQ6I0zNPpfagrN/w/+Igp3vtYdNunikw3yHnYf
+i7/CBjPKOyKijtqVny7qrGOnU2ygcA88/WDibexDhrjz0Gx8WmErU7rIWZiZ5u4Y
-Jkm0MmaMDUM9mtsaXVN6xb9n25N3Xa3GWCpmdsbYZ8334tI/oQ4/NHq/bEI5WFH5F1aFkMkm
+vJYVRo0+6rBCXRPeSJfiP5h1p17Anr2l42boAYslfcrzquB8MHtrNcyn650OLtHG
-5AJVLuUkipCtmCZ5NkbRPJA9l0uNUUE6uuFXBhf4ddu7jb0jMetRF/kifJHVCCo5fISUNhLp
+nbxgIdniKrpuzGN6Opw+O2id2JhD1/1p4SOemwAmthplr1MIyOHNP3q93rEj2J7h
-7bwcWq9qgDQNZNYMOo4s9WX5Tl+5x4gTZdd2/cAYt49h/wnkw+huM+Jm0GojpLqIQ1jZiffm
+5zPS/AJuKkMDFUpslPNLQjCOwPXtdzL7/kUZGBSyez1T3TaW1uY6l9XaJJRaSn+v
-otf5rF4L+JhIIdW0W4IIh1v9BhHVllXw+z9oj0PALstT5h8/DuKoIiirFJ4DejU85GR1KKAS
+1zPgfp4GJ3lPs4AlAbQ0RXRoZXJldW0gRm91bmRhdGlvbiBCdWcgQm91bnR5IDxi
-DeO19G/lSpWj1rSgFv2N2gAOxq0X+BbQTua2jdcY6JpHR4H1JJ2wzfHsHPgDQcgY1rGlmjVF
+b3VudHlAZXRoZXJldW0ub3JnPokCPgQTAQIAKAIbAwYLCQgHAwIGFQgCCQoLBBYC
-aqU73WV4/hzXc/HshK/k4Zd8uD4zypv6rFsZ3UemK0aL2zXLVpV8SPWQ61nS03x675SmDlYr
+AwECHgECF4AFAloJYfoFCQWjYFgACgkQ6I0zNPpfagoENg/+LnSaVeMxiGVtcjWl
-A80ENfdqvsn00JQuBVIv4Tv0Ub7NfDraDGJCst8rObjBT/0vnBWTBCebb2EsnS2iStIFkWdz
+b7Xd73yrEy4uxiESS1AalW9mMf7oZzfI05f7QIQlaLAkNac74vZDJbPKjtb7tpMO
-/WXs4L4Yzre1iJwqRjiuqahZR5jHsjAUf2a0O29HVHE7zlFtCFmLPClml2lGQfQOpm5klGZF
+RFhRZMCveq6CPKU6pd1SI8IUVUKwpEe6AJP3lHdVP57dquieFE2HlYKm6uHbCGWU
-rmvus+qZ9rt35UgWHPZezykkwtWrFOwspwuCWaPDto6tgbRJZ4ftitpdYYM3dKW9IGJXBwrt
+0cjyTA+uu2KbgCHGmofsPY/xOcZLGEHTHqa5w60JJAQm+BSDKnw8wTyrxGvA3EK/
-BQrMsu+lp0vDF+yJAlUEEwEIAD8CGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAFiEErpbt
+ePSvOZMYa+iw6vYuZeBIMbdiXR/A2keBi3GuvqB8tDMj7P22TrH5mVDm3zNqGYD6
-lp5HmwCE8+F/6I0zNPpfagoFAmEAEJwFCQycmLgACgkQ6I0zNPpfagpWoBAAhOcbMAUw6Zt0
+amDPeiWp4cztY3aZyLcgYotqXPpDceZzDn+HopBPzAb/llCdE7bVswKRhphVMw4b
-GYzT3sR5/c0iatezPzXEXJf9ebzR8M5uPElXcxcnMx1dvXZmGPXPJKCPa99WCu1NZYy8F+Wj
+bhL0R/TQY7Sf6TK2LKSBrjv0DWOSijikE71SJcBnJvHU7EpKrQQ0lMGclm3ynyji
-GTOY9tfIkvSxhys1p/giPAmvid6uQmD+bz7ivktnyzCkDWfMA+l8lsCSEqVlaq6y5T+a6SWB
+Nf0YTPXQt4I+fwTmOew2GFeK3UytNWbWI7oXX7Nm4bj9bhf3IJ0kmZb/Gs73+xII
-6TzC2S0MPb/RrC/7DpwyrNYWumvyVJh09adm1Mw/UGgst/sZ8eMaRYEd3X0yyT1CBpX4zp2E
+e7Rz52Mby436tWyQIQiF9ITYNGvNf53TwBBZMn0pKPiTyr3Ur7FHEotkEOFNh1//
-qQj9IEOTizvzv1x2jkHe5ZUeU3+nTBNlhSA+WFHUi0pfBdo2qog3Mv2EC1P2qMKoSdD5tPbA
+4zQY10XxuBdLrYGyZ4V8xHJM+oKre8Eg2R9qHXVbjvErHE+7CvgnV7YUip0criPr
-zql1yKoHHnXOMsqdftGwbiv2sYXWvrYvmaCd3Ys/viOyt3HOy9uV2ZEtBd9Yqo9x/NZj8QMA
+BlKRvuoJaSliH2JFhSjWVrkPmFGrWN0BAx10yIqMnEplfKeHf4P9Elek3oInS8WP
-nY5k8jjrIXbUC89MqrJsQ6xxWQIg5ikMT7DvY0Ln89ev4oJyVvwIQAwCm4jUzFNm9bZLYDOP
+G1zJG6s/t5+hQK0X37+TB+6rd3GJAj4EEwECACgFAlgl4TsCGwMFCQHhM4AGCwkI
-5lGJCV7tF5NYVU7NxNM8vescKc40mVNK/pygS5mxhK9QYOUjZsIv8gddrl1TkqrFMuxFnTyN
+BwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEOiNMzT6X2oKzf8P/iIKd77WHTbp4pMN
-WvzE29wFu/n4N1DkF+ZBqS70SlRvB+Hjz5LrDgEzF1Wf1eA/wq1dZbvMjjDVIc2VGlYp8Cp2
+8h52HyZJtDJmjA1DPZrbGl1TesW/Z9uTd12txlgqZnbG2GfN9+LSP6EOPzR6v2xC
-8ob23c1seTtYXTNYgSR5go4EpH+xi+bIWv01bQQ9xGwBbT5sm4WUeWOcmX4QewzLZ3T/wK9+
+OVhR+RdWhZDJJuQCVS7lJIqQrZgmeTZG0TyQPZdLjVFBOrrhVwYX+HXbu429IzHr
-N4Ye/hmU9O34FwWJOY58EIe0OUV0aGVyZXVtIEZvdW5kYXRpb24gU2VjdXJpdHkgVGVhbSA8
+URf5InyR1QgqOXyElDYS6e28HFqvaoA0DWTWDDqOLPVl+U5fuceIE2XXdv3AGLeP
-c2VjdXJpdHlAZXRoZXJldW0ub3JnPokCHAQRAQgABgUCWhQmOgAKCRB6DAN0NP5372LSEACT
+Yf8J5MPobjPiZtBqI6S6iENY2Yn35qLX+axeC/iYSCHVtFuCCIdb/QYR1ZZV8Ps/
-wZk1TASWZj5QF7rmkIM1GEyBxLE+PundNcMgM9Ktj1315ED8SmiukNI4knVS1MY99OIgXhQl
+aI9DwC7LU+YfPw7iqCIoqxSeA3o1PORkdSigEg3jtfRv5UqVo9a0oBb9jdoADsat
-D1foF2GKdTomrwwC4012zTNyUYCY60LnPZ6Z511HG+rZgZtZrbkz0IiUpwAlhGQND77lBqem
+F/gW0E7mto3XGOiaR0eB9SSdsM3x7Bz4A0HIGNaxpZo1RWqlO91leP4c13Px7ISv
-J3K+CFX2XpDA/ojui/kqrY4cwMT5P8xPJkwgpRgw/jgdcZyJTsXdHblV9IGU4H1Vd1SgcfAf
+5OGXfLg+M8qb+qxbGd1HpitGi9s1y1aVfEj1kOtZ0tN8eu+Upg5WKwPNBDX3ar7J
-Db3YxDUlBtzlp0NkZqxen8irLIXUQvsfuIfRUbUSkWoK/n3U/gOCajAe8ZNF07iX4OWjH4Sw
+9NCULgVSL+E79FG+zXw62gxiQrLfKzm4wU/9L5wVkwQnm29hLJ0tokrSBZFnc/1l
-NDA841WhFWcGE+d8+pfMVfPASU3UPKH72uw86b2VgR46Av6voyMFd1pj+yCA+YAhJuOpV4yL
+7OC+GM63tYicKkY4rqmoWUeYx7IwFH9mtDtvR1RxO85RbQhZizwpZpdpRkH0DqZu
-QaGg2Z0kVOjuNWK/kBzp1F58DWGh4YBatbhE/UyQOqAAtR7lNf0M3QF9AdrHTxX8oZeqVW3V
+ZJRmRa5r7rPqmfa7d+VIFhz2Xs8pJMLVqxTsLKcLglmjw7aOrYG0SWeH7YraXWGD
-Fmi2mk0NwCIUv8SSrZr1dTchp04OtyXe5gZBXSfzncCSRQIUDC8OgNWaOzAaUmK299v4bvye
+N3SlvSBiVwcK7QUKzLLvpadLwxfsuQINBFgl3tgBEACbgq6HTN5gEBi0lkD/MafI
-uSCxOysxC7Q1hZtjzFPKdljS81mRlYeUL4fHlJU9R57bg8mriSXLmn7eKrSEDm/EG5T8nRx7
+nmNi+59U5gRGYqk46WlfRjhHudXjDpgD0lolGb4hYontkMaKRlCg2Rvgjvk3Zve0
-TgX2MqJs8sWFxD2+bboVEu75yuFmZ//nmCBApAit9Hr2/sCshGIEpa9MQ6xJCYUxyqeJH+Cc
+PKWjKw7gr8YBa9fMFY8BhAXI32OdyI9rFhxEZFfWAfwKVmT19BdeAQRFvcfd+8w8
-Aja0UfXhnK2uvPClpJLIl4RE3gm4OXeE1IkCPgQTAQIAKAIbAwYLCQgHAwIGFQgCCQoLBBYC
+f1XVc+zddULMJFBTr+xKDlIRWwTkdLPQeWbjo0eHl/g4tuLiLrTxVbnj26bf+2+1
-AwECHgECF4AFAloJYfoFCQWjYFgACgkQ6I0zNPpfagr4MQ//cfp3GSbSG8dkqgctW67Fy7cQ
+DbM/w5VavzPrkviHqvKe/QP/gay4QDViWvFgLb90idfAHIdsPgflp0VDS5rVHFL6
-diiTmx3cwxY+tlI3yrNmdjtrIQMzGdqtY6LNz7aN87F8mXNf+DyVHX9+wd1Y8U+E+hVCTzKC
+D73rSRdIRo3I8c8mYoNjSR4XDuvgOkAKW9LR3pvouFHHjp6Fr0GesRbrbb2EG66i
-sefUfxTz6unD9TTcGqaoelgIPMn4IiKz1RZE6eKpfDWe6q78W1Y6x1bE0qGNSjqT/QSxpezF
+PsR99MQ7FqIL9VMHPm2mtR+XvbnKkH2rYyEqaMbSdk29jGapkAWle4sIhSKk749A
-E/OAm/t8RRxVxDtqz8LfH2zLea5zaC+ADj8EqgY9vX9TQa4DyVV8MgOyECCCadJQCD5O5hIA
+4tGkHl08KZ2N9o6GrfUehP/V2eJLaph2DioFL1HxRryrKy80QQKLMJRekxigq8gr
-B2gVDWwrAUw+KBwskXZ7Iq4reJTKLEmt5z9zgtJ/fABwaCFt66ojwg0/RjbO9cNA3ZwHLGwU
+eW8xB4zuf9Mkuou+RHNmo8PebHjFstLigiD6/zP2e+4tUmrT0/JTGOShoGMl8Rt0
-C6hkb6bRzIoZoMfYxVS84opiqf/Teq+t/XkBYCxbSXTJDA5MKjcVuw3N6YKWbkGP/EfQThe7
+VRxdPImKun+4LOXbfOxArOSkY6i35+gsgkkSy1gTJE0BY3S9auT6+YrglY/TWPQ9
-BfAKFwwIw5YmsWjHK8IQj6R6hBxzTz9rz8y1Lu8EAAFfA7OJKaboI2qbOlauH98OuOUmVtr1
+IJxWVOKlT+3WIp5wJu2bBKQ420VLqDYzkoWytel/bM1ACUtipMiIVeUs2uFiRjpz
-TczHO+pTcgWVN0ytq2/pX5KBf4vbmULNbg3HFRq+gHx8CW+jyXGkcqjbgU/5FwtDxeqRTdGJ
+A1Wy0QHKPTdSuGlJPRrfcQARAQABiQIlBBgBAgAPAhsMBQJaCWIIBQkFo2BYAAoJ
-SyBGNBEU6pBNolyynyaKaaJjJ/biY27pvjymL5rlz95BH3Dn16Z4RRmqwlT6eq/wFYginujg
+EOiNMzT6X2oKgSwQAKKs7BGF8TyZeIEO2EUK7R2bdQDCdSGZY06tqLFg3IHMGxDM
-CCE1icqOSE+Vjl7V8tV8AcgANkXKdbBE+Q8wlKsGI/kS1w4XFAYcaNHFT8qNeS8TSFXFhvU8
+b/7FVoa2AEsFgv6xpoebxBB5zkhUk7lslgxvKiSLYjxfNjTBltfiFJ+eQnf+OTs8
-HylYxO79t56JAj4EEwECACgFAlgl3tgCGwMFCQHhM4AGCwkIBwMCBhUIAgkKCwQWAgMBAh4B
+KeR51lLa66rvIH2qUzkNDCCTF45H4wIDpV05AXhBjKYkrDCrtey1rQyFp5fxI+0I
-AheAAAoJEOiNMzT6X2oKmUMP/0hnaL6bVyepAq2LIdvIUbHfagt/Oo/KVfZs4bkM+xJOitJR
+Q1UKKXvzZK4GdxhxDbOUSd38MYy93nqcmclGSGK/gF8XiyuVjeifDCM6+T1NQTX0
-0kwZV9PTihXFdzhL/YNWc2+LtEBtKItqkJZKmWC0E6OPXGVuU6hfFPebuzVccYJfm0Q3Ej19
+K9lneidcqtBDvlggJTLJtQPO33o5EHzXSiud+dKth1uUhZOFEaYRZoye1YE3yB0T
-VJI9Uomf59Bpak8HYyEED7WVQjoYn7XVPsonwus/9+LDX+c5vutbrUdbjga3KjHbewD93X4O
+NOOE8fXlvu8iuIAMBSDL9ep6sEIaXYwoD60I2gHdWD0lkP0DOjGQpi4ouXM3Edsd
-wVVoXyHEmU2Plyg8qvzFbNDylCWO7N2McO6SN6+7DitGZGr2+jO+P2R4RT1cnl2V3IRVcWZ0
+5MTi0MDRNTij431kn8T/D0LCgmoUmYYMBgbwFhXr67axPZlKjrqR0z3F/Elv0ZPP
-OTspPSnRGVr2fFiHN/+v8G/wHPLQcJZFvYPfUGNdcYbTmhWdiY0bEYXFiNrgzCCsyad7eKUR
+cVg1tNznsALYQ9Ovl6b5M3cJ5GapbbvNWC7yEE1qScl9HiMxjt/H6aPastH63/7w
-WN9QmxqmyqLDjUEDJCAh19ES6Vg3tqGwXk+uNUCoF30ga0TxQt6UXZJDEQFAGeASQ/RqE/q1
+cN0TslW+zRBy05VNJvpWGStQXcngsSUeJtI1Gd992YNjUJq4/Lih6Z1TlwcFVap+
-EAuLv8IGM8o7IqKO2pWfLuqsY6dTbKBwDzz9YOJt7EOGuPPQbHxaYStTushZmJnm7hi8lhVG
+cTcDptoUvXYGg/9mRNNPZwErSfIJ0Ibnx9wPVuRN6NiCLOt2mtKp2F1pM6AOQPpZ
-jT7qsEJdE95Il+I/mHWnXsCevaXjZugBiyV9yvOq4Hwwe2s1zKfrnQ4u0cadvGAh2eIqum7M
+85vEh6I8i6OaO0w/Z0UHBwvpY6jDUliaROsWUQsqz78Z34CVj4cy6vPW2EF4
-Y3o6nD47aJ3YmEPX/WnhI56bACa2GmWvUwjI4c0/er3esSPYnuHnM9L8Am4qQwMVSmyU80tC
+=r6KK
-MI7A9e13Mvv+RRkYFLJ7PVPdNpbW5jqX1doklFpKf6/XM+B+ngYneU+zgCUBiQJVBBMBCAA/
+-----END PGP PUBLIC KEY BLOCK-----
-AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgBYhBK6W7ZaeR5sAhPPhf+iNMzT6X2oKBQJh
-ABCQBQkMnJi4AAoJEOiNMzT6X2oKAv0P+gJ3twBp5efNWyVLcIg4h4cOo9uD0NPvz8/fm2gX
-FoOJL3MeigtPuSVfE9kuTaTuRbArzuFtdvH6G/kcRQvOlO4zyiIRHCk1gDHoIvvtn6RbRhVm
-/Xo4uGIsFHst7n4A7BjicwEK5Op6Ih5Hoq19xz83YSBgBVk2fYEJIRyJiKFbyPjH0eSYe8v+
-Ra5/F85ugLx1P6mMVkW+WPzULns89riW7BGTnZmXFHZp8nO2pkUlcI7F3KRG7l4kmlC50ox6
-DiG/6AJCVulbAClky9C68TmJ/R1RazQxU/9IqVywsydq66tbJQbm5Z7GEti0C5jjbSRJL2oT
-1xC7Rilr85PMREkPL3vegJdgj5PKlffZ/MocD/0EohiQ7wFpejFD4iTljeh0exRUwCRb6655
-9ib34JSQgU8Hl4JJu+mEgd9v0ZHD0/1mMD6fnAR84zca+O3cdASbnQmzTOKcGzLIrkE8TEnU
-+2UZ8Ol7SAAqmBgzY1gKOilUho6dkyCAwNL+QDpvrITDPLEFPsjyB/M2KudZSVEn+Rletju1
-qkMW31qFMNlsbwzMZw+0USeGcs31Cs0B2/WQsro99CExlhS9auUFkmoVjJmYVTIYOM0zuPa4
-OyGspqPhRu5hEsmMDPDWD7Aad5k4GTqogQNnuKyRliZjXXrDZqFD5nfsJSL8Ky/sJGEMuQIN
-BFgl3tgBEACbgq6HTN5gEBi0lkD/MafInmNi+59U5gRGYqk46WlfRjhHudXjDpgD0lolGb4h
-YontkMaKRlCg2Rvgjvk3Zve0PKWjKw7gr8YBa9fMFY8BhAXI32OdyI9rFhxEZFfWAfwKVmT1
-9BdeAQRFvcfd+8w8f1XVc+zddULMJFBTr+xKDlIRWwTkdLPQeWbjo0eHl/g4tuLiLrTxVbnj
-26bf+2+1DbM/w5VavzPrkviHqvKe/QP/gay4QDViWvFgLb90idfAHIdsPgflp0VDS5rVHFL6
-D73rSRdIRo3I8c8mYoNjSR4XDuvgOkAKW9LR3pvouFHHjp6Fr0GesRbrbb2EG66iPsR99MQ7
-FqIL9VMHPm2mtR+XvbnKkH2rYyEqaMbSdk29jGapkAWle4sIhSKk749A4tGkHl08KZ2N9o6G
-rfUehP/V2eJLaph2DioFL1HxRryrKy80QQKLMJRekxigq8greW8xB4zuf9Mkuou+RHNmo8Pe
-bHjFstLigiD6/zP2e+4tUmrT0/JTGOShoGMl8Rt0VRxdPImKun+4LOXbfOxArOSkY6i35+gs
-gkkSy1gTJE0BY3S9auT6+YrglY/TWPQ9IJxWVOKlT+3WIp5wJu2bBKQ420VLqDYzkoWytel/
-bM1ACUtipMiIVeUs2uFiRjpzA1Wy0QHKPTdSuGlJPRrfcQARAQABiQIlBBgBAgAPAhsMBQJa
-CWIIBQkFo2BYAAoJEOiNMzT6X2oKgSwQAKKs7BGF8TyZeIEO2EUK7R2bdQDCdSGZY06tqLFg
-3IHMGxDMb/7FVoa2AEsFgv6xpoebxBB5zkhUk7lslgxvKiSLYjxfNjTBltfiFJ+eQnf+OTs8
-KeR51lLa66rvIH2qUzkNDCCTF45H4wIDpV05AXhBjKYkrDCrtey1rQyFp5fxI+0IQ1UKKXvz
-ZK4GdxhxDbOUSd38MYy93nqcmclGSGK/gF8XiyuVjeifDCM6+T1NQTX0K9lneidcqtBDvlgg
-JTLJtQPO33o5EHzXSiud+dKth1uUhZOFEaYRZoye1YE3yB0TNOOE8fXlvu8iuIAMBSDL9ep6
-sEIaXYwoD60I2gHdWD0lkP0DOjGQpi4ouXM3Edsd5MTi0MDRNTij431kn8T/D0LCgmoUmYYM
-BgbwFhXr67axPZlKjrqR0z3F/Elv0ZPPcVg1tNznsALYQ9Ovl6b5M3cJ5GapbbvNWC7yEE1q
-Scl9HiMxjt/H6aPastH63/7wcN0TslW+zRBy05VNJvpWGStQXcngsSUeJtI1Gd992YNjUJq4
-/Lih6Z1TlwcFVap+cTcDptoUvXYGg/9mRNNPZwErSfIJ0Ibnx9wPVuRN6NiCLOt2mtKp2F1p
-M6AOQPpZ85vEh6I8i6OaO0w/Z0UHBwvpY6jDUliaROsWUQsqz78Z34CVj4cy6vPW2EF4iQIl
-BBgBAgAPBQJYJd7YAhsMBQkB4TOAAAoJEOiNMzT6X2oKTjgP/1ojCVyGyvHMLUgnX0zwrR5Q
-1M5RKFz6kHwKjODVLR3Isp8I935oTQt3DY7yFDI4t0GqbYRQMtxcNEb7maianhK2trCXfhPs
-6/L04igjDf5iTcmzamXN6xnh5xkz06hZJJCMuu4MvKxC9MQHCVKAwjswl/9H9JqIBXAY3E2l
-LpX5P+5jDZuPxS86p3+k4Rrdp9KTGXjiuEleM3zGlz5BLWydqovOck7C2aKh27ETFpDYY0z3
-yQ5AsPJyk1rAr0wrH6+ywmwWlzuQewavnrLnJ2M8iMFXpIhyHeEIU/f7o8f+dQk72rZ9CGzd
-cqig2za/BS3zawZWgbv2vB2elNsIllYLdir45jxBOxx2yvJvEuu4glz78y4oJTCTAYAbMlle
-5gVdPkVcGyvvVS9tinnSaiIzuvWrYHKWll1uYPm2Q1CDs06P5I7bUGAXpgQLUh/XQguy/0sX
-GWqW3FS5JzP+XgcR/7UASvwBdHylubKbeqEpB7G1s+m+8C67qOrc7EQv3Jmy1YDOkhEyNig1
-rmjplLuir3tC1X+D7dHpn7NJe7nMwFx2b2MpMkLA9jPPAGPp/ekcu5sxCe+E0J/4UF++K+CR
-XIxgtzU2UJfp8p9x+ygbx5qHinR0tVRdIzv3ZnGsXrfxnWfSOaB582cU3VRN9INzHHax8ETa
-QVDnGO5uQa+FiQI8BBgBCAAmAhsMFiEErpbtlp5HmwCE8+F/6I0zNPpfagoFAmEAELYFCQyc
-mN4ACgkQ6I0zNPpfagoqAQ/+MnDjBx8JWMd/XjeFoYKx/Oo0ntkInV+ME61JTBls4PdVk+TB
-8PWZdPQHw9SnTvRmykFeznXIRzuxkowjrZYXdPXBxY2b1WyD5V3Ati1TM9vqpaR4osyPs2xy
-I4dzDssh9YvUsIRL99O04/65lGiYeBNuACq+yK/7nD/ErzBkDYJHhMCdadbVWUACxvVIDvro
-yQeVLKMsHqMCd8BTGD7VDs79NXskPnN77pAFnkzS4Z2b8SNzrlgTc5pUiuZHIXPIpEYmsYzh
-ucTU6uI3dN1PbSFHK5tG2pHb4ZrPxY3L20Dgc2Tfu5/SDApZzwvvKTqjdO891MEJ++H+ssOz
-i4O1UeWKs9owWttan9+PI47ozBSKOTxmMqLSQ0f56Np9FJsV0ilGxRKfjhzJ4KniOMUBA7mP
-+m+TmXfVtthJred4sHlJMTJNpt+sCcT6wLMmyc3keIEAu33gsJj3LTpkEA2q+V+ZiP6Q8HRB
-402ITklABSArrPSE/fQU9L8hZ5qmy0Z96z0iyILgVMLuRCCfQOMWhwl8yQWIIaf1yPI07xur
-epy6lH7HmxjjOR7eo0DaSxQGQpThAtFGwkWkFh8yki8j3E42kkrxvEyyYZDXn2YcI3bpqhJx
-PtwCMZUJ3kc/skOrs6bOI19iBNaEoNX5Dllm7UHjOgWNDQkcCuOCxucKano=
-=arte
------END PGP PUBLIC KEY BLOCK------
 ```

accounts/abi/abi.go

@@ -34,7 +34,6 @@ type ABI struct {
 	Constructor Method
 	Methods     map[string]Method
 	Events      map[string]Event
-	Errors      map[string]Error
 
 	// Additional "special" functions introduced in solidity v0.6.0.
 	// It's separated from the original default fallback. Each contract
@@ -158,13 +157,12 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 	}
 	abi.Methods = make(map[string]Method)
 	abi.Events = make(map[string]Event)
-	abi.Errors = make(map[string]Error)
 	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 := overloadedName(field.Name, func(s string) bool { _, ok := abi.Methods[s]; return ok })
+			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
@@ -184,10 +182,8 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 			}
 			abi.Receive = NewMethod("", "", Receive, field.StateMutability, field.Constant, field.Payable, nil, nil)
 		case "event":
-			name := overloadedName(field.Name, func(s string) bool { _, ok := abi.Events[s]; return ok })
+			name := abi.overloadedEventName(field.Name)
 			abi.Events[name] = NewEvent(name, field.Name, field.Anonymous, field.Inputs)
-		case "error":
-			abi.Errors[field.Name] = NewError(field.Name, field.Inputs)
 		default:
 			return fmt.Errorf("abi: could not recognize type %v of field %v", field.Type, field.Name)
 		}
@@ -195,6 +191,36 @@ func (abi *ABI) UnmarshalJSON(data []byte) error {
 	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.
 func (abi *ABI) MethodById(sigdata []byte) (*Method, error) {
@@ -251,20 +277,3 @@ func UnpackRevert(data []byte) (string, error) {
 	}
 	return unpacked[0].(string), nil
 }
-
-// overloadedName returns the next available name for a given thing.
-// Needed since solidity allows for overloading.
-//
-// e.g. if the abi contains Methods send, send1
-// overloadedName would return send2 for input send.
-//
-// overloadedName works for methods, events and errors.
-func overloadedName(rawName string, isAvail func(string) bool) string {
-	name := rawName
-	ok := isAvail(name)
-	for idx := 0; ok; idx++ {
-		name = fmt.Sprintf("%s%d", rawName, idx)
-		ok = isAvail(name)
-	}
-	return name
-}

accounts/abi/abi_test.go

@@ -295,20 +295,6 @@ func TestOverloadedMethodSignature(t *testing.T) {
 	check("bar0", "bar(uint256,uint256)", false)
 }
 
-func TestCustomErrors(t *testing.T) {
-	json := `[{ "inputs": [	{ "internalType": "uint256", "name": "", "type": "uint256" } ],"name": "MyError", "type": "error"} ]`
-	abi, err := JSON(strings.NewReader(json))
-	if err != nil {
-		t.Fatal(err)
-	}
-	check := func(name string, expect string) {
-		if abi.Errors[name].Sig != expect {
-			t.Fatalf("The signature of overloaded method mismatch, want %s, have %s", expect, abi.Methods[name].Sig)
-		}
-	}
-	check("MyError", "MyError(uint256)")
-}
-
 func TestMultiPack(t *testing.T) {
 	abi, err := JSON(strings.NewReader(jsondata))
 	if err != nil {

accounts/abi/argument.go

@@ -81,7 +81,13 @@ func (arguments Arguments) Unpack(data []byte) ([]interface{}, error) {
 		if len(arguments) != 0 {
 			return nil, fmt.Errorf("abi: attempting to unmarshall an empty string while arguments are expected")
 		}
-		return make([]interface{}, 0), nil
+		// 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)
 }
@@ -131,7 +137,7 @@ func (arguments Arguments) copyAtomic(v interface{}, marshalledValues interface{
 	dst := reflect.ValueOf(v).Elem()
 	src := reflect.ValueOf(marshalledValues)
 
-	if dst.Kind() == reflect.Struct {
+	if dst.Kind() == reflect.Struct && src.Kind() != reflect.Struct {
 		return set(dst.Field(0), src)
 	}
 	return set(dst, src)

accounts/abi/bind/backends/simulated.go

@@ -230,9 +230,6 @@ func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common
 	defer b.mu.Unlock()
 
 	receipt, _, _, _ := rawdb.ReadReceipt(b.database, txHash, b.config)
-	if receipt == nil {
-		return nil, ethereum.NotFound
-	}
 	return receipt, nil
 }
 
@@ -465,12 +462,6 @@ func (b *SimulatedBackend) PendingNonceAt(ctx context.Context, account common.Ad
 // SuggestGasPrice implements ContractTransactor.SuggestGasPrice. Since the simulated
 // chain doesn't have miners, we just return a gas price of 1 for any call.
 func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if b.pendingBlock.Header().BaseFee != nil {
-		return b.pendingBlock.Header().BaseFee, nil
-	}
 	return big.NewInt(1), nil
 }
 
@@ -642,6 +633,7 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM
 }
 
 // SendTransaction updates the pending block to include the given transaction.
+// It panics if the transaction is invalid.
 func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error {
 	b.mu.Lock()
 	defer b.mu.Unlock()
@@ -649,17 +641,17 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa
 	// Get the last block
 	block, err := b.blockByHash(ctx, b.pendingBlock.ParentHash())
 	if err != nil {
-		return fmt.Errorf("could not fetch parent")
+		panic("could not fetch parent")
 	}
 	// Check transaction validity
 	signer := types.MakeSigner(b.blockchain.Config(), block.Number())
 	sender, err := types.Sender(signer, tx)
 	if err != nil {
-		return fmt.Errorf("invalid transaction: %v", err)
+		panic(fmt.Errorf("invalid transaction: %v", err))
 	}
 	nonce := b.pendingState.GetNonce(sender)
 	if tx.Nonce() != nonce {
-		return fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)
+		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) {

accounts/abi/bind/backends/simulated_test.go

@@ -496,7 +496,7 @@ func TestEstimateGas(t *testing.T) {
 			GasPrice: big.NewInt(0),
 			Value:    nil,
 			Data:     common.Hex2Bytes("b9b046f9"),
-		}, 0, errors.New("invalid opcode: INVALID"), nil},
+		}, 0, errors.New("invalid opcode: opcode 0xfe not defined"), nil},
 
 		{"Valid", ethereum.CallMsg{
 			From:     addr,
@@ -916,8 +916,8 @@ func TestSuggestGasPrice(t *testing.T) {
 	if err != nil {
 		t.Errorf("could not get gas price: %v", err)
 	}
-	if gasPrice.Uint64() != sim.pendingBlock.Header().BaseFee.Uint64() {
+	if gasPrice.Uint64() != uint64(1) {
-		t.Errorf("gas price was not expected value of %v. actual: %v", sim.pendingBlock.Header().BaseFee.Uint64(), gasPrice.Uint64())
+		t.Errorf("gas price was not expected value of 1. actual: %v", gasPrice.Uint64())
 	}
 }
 

accounts/abi/bind/base.go

@@ -171,10 +171,7 @@ func (c *BoundContract) Call(opts *CallOpts, results *[]interface{}, method stri
 			return ErrNoPendingState
 		}
 		output, err = pb.PendingCallContract(ctx, msg)
-		if err != nil {
+		if err == nil && len(output) == 0 {
-			return err
-		}
-		if len(output) == 0 {
 			// Make sure we have a contract to operate on, and bail out otherwise.
 			if code, err = pb.PendingCodeAt(ctx, c.address); err != nil {
 				return err
@@ -234,158 +231,108 @@ func (c *BoundContract) Transfer(opts *TransactOpts) (*types.Transaction, error)
 	return c.transact(opts, &c.address, nil)
 }
 
-func (c *BoundContract) createDynamicTx(opts *TransactOpts, contract *common.Address, input []byte, head *types.Header) (*types.Transaction, error) {
-	// Normalize value
-	value := opts.Value
-	if value == nil {
-		value = new(big.Int)
-	}
-	// Estimate TipCap
-	gasTipCap := opts.GasTipCap
-	if gasTipCap == nil {
-		tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context))
-		if err != nil {
-			return nil, err
-		}
-		gasTipCap = tip
-	}
-	// Estimate FeeCap
-	gasFeeCap := opts.GasFeeCap
-	if gasFeeCap == nil {
-		gasFeeCap = new(big.Int).Add(
-			gasTipCap,
-			new(big.Int).Mul(head.BaseFee, big.NewInt(2)),
-		)
-	}
-	if gasFeeCap.Cmp(gasTipCap) < 0 {
-		return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", gasFeeCap, gasTipCap)
-	}
-	// Estimate GasLimit
-	gasLimit := opts.GasLimit
-	if opts.GasLimit == 0 {
-		var err error
-		gasLimit, err = c.estimateGasLimit(opts, contract, input, nil, gasTipCap, gasFeeCap, value)
-		if err != nil {
-			return nil, err
-		}
-	}
-	// create the transaction
-	nonce, err := c.getNonce(opts)
-	if err != nil {
-		return nil, err
-	}
-	baseTx := &types.DynamicFeeTx{
-		To:        contract,
-		Nonce:     nonce,
-		GasFeeCap: gasFeeCap,
-		GasTipCap: gasTipCap,
-		Gas:       gasLimit,
-		Value:     value,
-		Data:      input,
-	}
-	return types.NewTx(baseTx), nil
-}
-
-func (c *BoundContract) createLegacyTx(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
-	if opts.GasFeeCap != nil || opts.GasTipCap != nil {
-		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
-	}
-	// Normalize value
-	value := opts.Value
-	if value == nil {
-		value = new(big.Int)
-	}
-	// Estimate GasPrice
-	gasPrice := opts.GasPrice
-	if gasPrice == nil {
-		price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context))
-		if err != nil {
-			return nil, err
-		}
-		gasPrice = price
-	}
-	// Estimate GasLimit
-	gasLimit := opts.GasLimit
-	if opts.GasLimit == 0 {
-		var err error
-		gasLimit, err = c.estimateGasLimit(opts, contract, input, gasPrice, nil, nil, value)
-		if err != nil {
-			return nil, err
-		}
-	}
-	// create the transaction
-	nonce, err := c.getNonce(opts)
-	if err != nil {
-		return nil, err
-	}
-	baseTx := &types.LegacyTx{
-		To:       contract,
-		Nonce:    nonce,
-		GasPrice: gasPrice,
-		Gas:      gasLimit,
-		Value:    value,
-		Data:     input,
-	}
-	return types.NewTx(baseTx), nil
-}
-
-func (c *BoundContract) estimateGasLimit(opts *TransactOpts, contract *common.Address, input []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, error) {
-	if contract != nil {
-		// Gas estimation cannot succeed without code for method invocations.
-		if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil {
-			return 0, err
-		} else if len(code) == 0 {
-			return 0, ErrNoCode
-		}
-	}
-	msg := ethereum.CallMsg{
-		From:      opts.From,
-		To:        contract,
-		GasPrice:  gasPrice,
-		GasTipCap: gasTipCap,
-		GasFeeCap: gasFeeCap,
-		Value:     value,
-		Data:      input,
-	}
-	return c.transactor.EstimateGas(ensureContext(opts.Context), msg)
-}
-
-func (c *BoundContract) getNonce(opts *TransactOpts) (uint64, error) {
-	if opts.Nonce == nil {
-		return c.transactor.PendingNonceAt(ensureContext(opts.Context), opts.From)
-	} else {
-		return opts.Nonce.Uint64(), nil
-	}
-}
-
 // transact executes an actual transaction invocation, first deriving any missing
 // authorization fields, and then scheduling the transaction for execution.
 func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
+	var err error
+
+	// Ensure a valid value field and resolve the account nonce
+	value := opts.Value
+	if value == nil {
+		value = new(big.Int)
+	}
+	var nonce uint64
+	if opts.Nonce == nil {
+		nonce, err = c.transactor.PendingNonceAt(ensureContext(opts.Context), opts.From)
+		if err != nil {
+			return nil, fmt.Errorf("failed to retrieve account nonce: %v", err)
+		}
+	} else {
+		nonce = opts.Nonce.Uint64()
+	}
+	// Figure out reasonable gas price values
 	if opts.GasPrice != nil && (opts.GasFeeCap != nil || opts.GasTipCap != nil) {
 		return nil, errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified")
 	}
-	// Create the transaction
+	head, err := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil)
-	var (
-		rawTx *types.Transaction
-		err   error
-	)
-	if opts.GasPrice != nil {
-		rawTx, err = c.createLegacyTx(opts, contract, input)
-	} else {
-		// Only query for basefee if gasPrice not specified
-		if head, errHead := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil); errHead != nil {
-			return nil, errHead
-		} else if head.BaseFee != nil {
-			rawTx, err = c.createDynamicTx(opts, contract, input, head)
-		} else {
-			// Chain is not London ready -> use legacy transaction
-			rawTx, err = c.createLegacyTx(opts, contract, input)
-		}
-	}
 	if err != nil {
 		return nil, err
 	}
-	// Sign the transaction and schedule it for execution
+	if head.BaseFee != nil && opts.GasPrice == nil {
+		if opts.GasTipCap == nil {
+			tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context))
+			if err != nil {
+				return nil, err
+			}
+			opts.GasTipCap = tip
+		}
+		if opts.GasFeeCap == nil {
+			gasFeeCap := new(big.Int).Add(
+				opts.GasTipCap,
+				new(big.Int).Mul(head.BaseFee, big.NewInt(2)),
+			)
+			opts.GasFeeCap = gasFeeCap
+		}
+		if opts.GasFeeCap.Cmp(opts.GasTipCap) < 0 {
+			return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", opts.GasFeeCap, opts.GasTipCap)
+		}
+	} else {
+		if opts.GasFeeCap != nil || opts.GasTipCap != nil {
+			return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet")
+		}
+		if opts.GasPrice == nil {
+			price, err := c.transactor.SuggestGasPrice(ensureContext(opts.Context))
+			if err != nil {
+				return nil, err
+			}
+			opts.GasPrice = price
+		}
+	}
+	gasLimit := opts.GasLimit
+	if gasLimit == 0 {
+		// Gas estimation cannot succeed without code for method invocations
+		if contract != nil {
+			if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil {
+				return nil, err
+			} else if len(code) == 0 {
+				return nil, ErrNoCode
+			}
+		}
+		// If the contract surely has code (or code is not needed), estimate the transaction
+		msg := ethereum.CallMsg{From: opts.From, To: contract, GasPrice: opts.GasPrice, GasTipCap: opts.GasTipCap, GasFeeCap: opts.GasFeeCap, Value: value, Data: input}
+		gasLimit, err = c.transactor.EstimateGas(ensureContext(opts.Context), msg)
+		if err != nil {
+			return nil, fmt.Errorf("failed to estimate gas needed: %v", err)
+		}
+	}
+	// Create the transaction, sign it and schedule it for execution
+	var rawTx *types.Transaction
+	if opts.GasFeeCap == nil {
+		baseTx := &types.LegacyTx{
+			Nonce:    nonce,
+			GasPrice: opts.GasPrice,
+			Gas:      gasLimit,
+			Value:    value,
+			Data:     input,
+		}
+		if contract != nil {
+			baseTx.To = &c.address
+		}
+		rawTx = types.NewTx(baseTx)
+	} else {
+		baseTx := &types.DynamicFeeTx{
+			Nonce:     nonce,
+			GasFeeCap: opts.GasFeeCap,
+			GasTipCap: opts.GasTipCap,
+			Gas:       gasLimit,
+			Value:     value,
+			Data:      input,
+		}
+		if contract != nil {
+			baseTx.To = &c.address
+		}
+		rawTx = types.NewTx(baseTx)
+	}
 	if opts.Signer == nil {
 		return nil, errors.New("no signer to authorize the transaction with")
 	}
@@ -484,9 +431,6 @@ 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 log.Topics[0] != c.abi.Events[event].ID {
-		return fmt.Errorf("event signature mismatch")
-	}
 	if len(log.Data) > 0 {
 		if err := c.abi.UnpackIntoInterface(out, event, log.Data); err != nil {
 			return err
@@ -503,9 +447,6 @@ func (c *BoundContract) UnpackLog(out interface{}, event string, log types.Log)
 
 // UnpackLogIntoMap unpacks a retrieved log into the provided map.
 func (c *BoundContract) UnpackLogIntoMap(out map[string]interface{}, event string, log types.Log) error {
-	if log.Topics[0] != c.abi.Events[event].ID {
-		return fmt.Errorf("event signature mismatch")
-	}
 	if len(log.Data) > 0 {
 		if err := c.abi.UnpackIntoMap(out, event, log.Data); err != nil {
 			return err

accounts/abi/bind/base_test.go

@@ -18,7 +18,6 @@ package bind_test
 
 import (
 	"context"
-	"errors"
 	"math/big"
 	"reflect"
 	"strings"
@@ -32,95 +31,37 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/stretchr/testify/assert"
 )
 
-func mockSign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) { return tx, nil }
-
-type mockTransactor struct {
-	baseFee                *big.Int
-	gasTipCap              *big.Int
-	gasPrice               *big.Int
-	suggestGasTipCapCalled bool
-	suggestGasPriceCalled  bool
-}
-
-func (mt *mockTransactor) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
-	return &types.Header{BaseFee: mt.baseFee}, nil
-}
-
-func (mt *mockTransactor) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) {
-	return []byte{1}, nil
-}
-
-func (mt *mockTransactor) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) {
-	return 0, nil
-}
-
-func (mt *mockTransactor) SuggestGasPrice(ctx context.Context) (*big.Int, error) {
-	mt.suggestGasPriceCalled = true
-	return mt.gasPrice, nil
-}
-
-func (mt *mockTransactor) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
-	mt.suggestGasTipCapCalled = true
-	return mt.gasTipCap, nil
-}
-
-func (mt *mockTransactor) EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) {
-	return 0, nil
-}
-
-func (mt *mockTransactor) SendTransaction(ctx context.Context, tx *types.Transaction) error {
-	return nil
-}
-
 type mockCaller struct {
-	codeAtBlockNumber       *big.Int
+	codeAtBlockNumber         *big.Int
-	callContractBlockNumber *big.Int
+	callContractBlockNumber   *big.Int
-	callContractBytes       []byte
+	pendingCodeAtCalled       bool
-	callContractErr         error
+	pendingCallContractCalled bool
-	codeAtBytes             []byte
-	codeAtErr               error
 }
 
 func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
 	mc.codeAtBlockNumber = blockNumber
-	return mc.codeAtBytes, mc.codeAtErr
+	return []byte{1, 2, 3}, nil
 }
 
 func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
 	mc.callContractBlockNumber = blockNumber
-	return mc.callContractBytes, mc.callContractErr
+	return nil, nil
 }
 
-type mockPendingCaller struct {
+func (mc *mockCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
-	*mockCaller
-	pendingCodeAtBytes        []byte
-	pendingCodeAtErr          error
-	pendingCodeAtCalled       bool
-	pendingCallContractCalled bool
-	pendingCallContractBytes  []byte
-	pendingCallContractErr    error
-}
-
-func (mc *mockPendingCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
 	mc.pendingCodeAtCalled = true
-	return mc.pendingCodeAtBytes, mc.pendingCodeAtErr
+	return nil, nil
 }
 
-func (mc *mockPendingCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
+func (mc *mockCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
 	mc.pendingCallContractCalled = true
-	return mc.pendingCallContractBytes, mc.pendingCallContractErr
+	return nil, nil
 }
-
 func TestPassingBlockNumber(t *testing.T) {
 
-	mc := &mockPendingCaller{
+	mc := &mockCaller{}
-		mockCaller: &mockCaller{
-			codeAtBytes: []byte{1, 2, 3},
-		},
-	}
 
 	bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
 		Methods: map[string]abi.Method{
@@ -169,7 +110,7 @@ const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16
 func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
 	hash := crypto.Keccak256Hash([]byte("testName"))
 	topics := []common.Hash{
-		crypto.Keccak256Hash([]byte("received(string,address,uint256,bytes)")),
+		common.HexToHash("0x0"),
 		hash,
 	}
 	mockLog := newMockLog(topics, common.HexToHash("0x0"))
@@ -194,7 +135,7 @@ func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
 	}
 	hash := crypto.Keccak256Hash(sliceBytes)
 	topics := []common.Hash{
-		crypto.Keccak256Hash([]byte("received(string[],address,uint256,bytes)")),
+		common.HexToHash("0x0"),
 		hash,
 	}
 	mockLog := newMockLog(topics, common.HexToHash("0x0"))
@@ -219,7 +160,7 @@ func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
 	}
 	hash := crypto.Keccak256Hash(arrBytes)
 	topics := []common.Hash{
-		crypto.Keccak256Hash([]byte("received(address[2],address,uint256,bytes)")),
+		common.HexToHash("0x0"),
 		hash,
 	}
 	mockLog := newMockLog(topics, common.HexToHash("0x0"))
@@ -246,7 +187,7 @@ func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
 	var functionTy [24]byte
 	copy(functionTy[:], functionTyBytes[0:24])
 	topics := []common.Hash{
-		crypto.Keccak256Hash([]byte("received(function,address,uint256,bytes)")),
+		common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
 		common.BytesToHash(functionTyBytes),
 	}
 	mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
@@ -267,7 +208,7 @@ func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
 	bytes := []byte{1, 2, 3, 4, 5}
 	hash := crypto.Keccak256Hash(bytes)
 	topics := []common.Hash{
-		crypto.Keccak256Hash([]byte("received(bytes,address,uint256,bytes)")),
+		common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
 		hash,
 	}
 	mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
@@ -285,51 +226,6 @@ func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
 	unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
 }
 
-func TestTransactGasFee(t *testing.T) {
-	assert := assert.New(t)
-
-	// GasTipCap and GasFeeCap
-	// When opts.GasTipCap and opts.GasFeeCap are nil
-	mt := &mockTransactor{baseFee: big.NewInt(100), gasTipCap: big.NewInt(5)}
-	bc := bind.NewBoundContract(common.Address{}, abi.ABI{}, nil, mt, nil)
-	opts := &bind.TransactOpts{Signer: mockSign}
-	tx, err := bc.Transact(opts, "")
-	assert.Nil(err)
-	assert.Equal(big.NewInt(5), tx.GasTipCap())
-	assert.Equal(big.NewInt(205), tx.GasFeeCap())
-	assert.Nil(opts.GasTipCap)
-	assert.Nil(opts.GasFeeCap)
-	assert.True(mt.suggestGasTipCapCalled)
-
-	// Second call to Transact should use latest suggested GasTipCap
-	mt.gasTipCap = big.NewInt(6)
-	mt.suggestGasTipCapCalled = false
-	tx, err = bc.Transact(opts, "")
-	assert.Nil(err)
-	assert.Equal(big.NewInt(6), tx.GasTipCap())
-	assert.Equal(big.NewInt(206), tx.GasFeeCap())
-	assert.True(mt.suggestGasTipCapCalled)
-
-	// GasPrice
-	// When opts.GasPrice is nil
-	mt = &mockTransactor{gasPrice: big.NewInt(5)}
-	bc = bind.NewBoundContract(common.Address{}, abi.ABI{}, nil, mt, nil)
-	opts = &bind.TransactOpts{Signer: mockSign}
-	tx, err = bc.Transact(opts, "")
-	assert.Nil(err)
-	assert.Equal(big.NewInt(5), tx.GasPrice())
-	assert.Nil(opts.GasPrice)
-	assert.True(mt.suggestGasPriceCalled)
-
-	// Second call to Transact should use latest suggested GasPrice
-	mt.gasPrice = big.NewInt(6)
-	mt.suggestGasPriceCalled = false
-	tx, err = bc.Transact(opts, "")
-	assert.Nil(err)
-	assert.Equal(big.NewInt(6), tx.GasPrice())
-	assert.True(mt.suggestGasPriceCalled)
-}
-
 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 {
@@ -359,132 +255,3 @@ func newMockLog(topics []common.Hash, txHash common.Hash) types.Log {
 		Removed:     false,
 	}
 }
-
-func TestCall(t *testing.T) {
-	var method, methodWithArg = "something", "somethingArrrrg"
-	tests := []struct {
-		name, method string
-		opts         *bind.CallOpts
-		mc           bind.ContractCaller
-		results      *[]interface{}
-		wantErr      bool
-		wantErrExact error
-	}{{
-		name: "ok not pending",
-		mc: &mockCaller{
-			codeAtBytes: []byte{0},
-		},
-		method: method,
-	}, {
-		name: "ok pending",
-		mc: &mockPendingCaller{
-			pendingCodeAtBytes: []byte{0},
-		},
-		opts: &bind.CallOpts{
-			Pending: true,
-		},
-		method: method,
-	}, {
-		name:    "pack error, no method",
-		mc:      new(mockCaller),
-		method:  "else",
-		wantErr: true,
-	}, {
-		name: "interface error, pending but not a PendingContractCaller",
-		mc:   new(mockCaller),
-		opts: &bind.CallOpts{
-			Pending: true,
-		},
-		method:       method,
-		wantErrExact: bind.ErrNoPendingState,
-	}, {
-		name: "pending call canceled",
-		mc: &mockPendingCaller{
-			pendingCallContractErr: context.DeadlineExceeded,
-		},
-		opts: &bind.CallOpts{
-			Pending: true,
-		},
-		method:       method,
-		wantErrExact: context.DeadlineExceeded,
-	}, {
-		name: "pending code at error",
-		mc: &mockPendingCaller{
-			pendingCodeAtErr: errors.New(""),
-		},
-		opts: &bind.CallOpts{
-			Pending: true,
-		},
-		method:  method,
-		wantErr: true,
-	}, {
-		name: "no pending code at",
-		mc:   new(mockPendingCaller),
-		opts: &bind.CallOpts{
-			Pending: true,
-		},
-		method:       method,
-		wantErrExact: bind.ErrNoCode,
-	}, {
-		name: "call contract error",
-		mc: &mockCaller{
-			callContractErr: context.DeadlineExceeded,
-		},
-		method:       method,
-		wantErrExact: context.DeadlineExceeded,
-	}, {
-		name: "code at error",
-		mc: &mockCaller{
-			codeAtErr: errors.New(""),
-		},
-		method:  method,
-		wantErr: true,
-	}, {
-		name:         "no code at",
-		mc:           new(mockCaller),
-		method:       method,
-		wantErrExact: bind.ErrNoCode,
-	}, {
-		name: "unpack error missing arg",
-		mc: &mockCaller{
-			codeAtBytes: []byte{0},
-		},
-		method:  methodWithArg,
-		wantErr: true,
-	}, {
-		name: "interface unpack error",
-		mc: &mockCaller{
-			codeAtBytes: []byte{0},
-		},
-		method:  method,
-		results: &[]interface{}{0},
-		wantErr: true,
-	}}
-	for _, test := range tests {
-		bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
-			Methods: map[string]abi.Method{
-				method: {
-					Name:    method,
-					Outputs: abi.Arguments{},
-				},
-				methodWithArg: {
-					Name:    methodWithArg,
-					Outputs: abi.Arguments{abi.Argument{}},
-				},
-			},
-		}, test.mc, nil, nil)
-		err := bc.Call(test.opts, test.results, test.method)
-		if test.wantErr || test.wantErrExact != nil {
-			if err == nil {
-				t.Fatalf("%q expected error", test.name)
-			}
-			if test.wantErrExact != nil && !errors.Is(err, test.wantErrExact) {
-				t.Fatalf("%q expected error %q but got %q", test.name, test.wantErrExact, err)
-			}
-			continue
-		}
-		if err != nil {
-			t.Fatalf("%q unexpected error: %v", test.name, err)
-		}
-	}
-}

accounts/abi/bind/bind.go

@@ -88,13 +88,6 @@ func Bind(types []string, abis []string, bytecodes []string, fsigs []map[string]
 			transactIdentifiers = make(map[string]bool)
 			eventIdentifiers    = make(map[string]bool)
 		)
-
-		for _, input := range evmABI.Constructor.Inputs {
-			if hasStruct(input.Type) {
-				bindStructType[lang](input.Type, structs)
-			}
-		}
-
 		for _, original := range evmABI.Methods {
 			// Normalize the method for capital cases and non-anonymous inputs/outputs
 			normalized := original

accounts/abi/bind/bind_test.go

@@ -1785,176 +1785,6 @@ var bindTests = []struct {
 		nil,
 		nil,
 	},
-	// Test resolving single struct argument
-	{
-		`NewSingleStructArgument`,
-		`
-		 pragma solidity ^0.8.0;
-
-		 contract NewSingleStructArgument {
-			 struct MyStruct{
-				 uint256 a;
-				 uint256 b;
-			 }
-			 event StructEvent(MyStruct s);
-			 function TestEvent() public {
-				 emit StructEvent(MyStruct({a: 1, b: 2}));
-			 }
-		 }
-	   `,
-		[]string{"608060405234801561001057600080fd5b50610113806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806324ec1d3f14602d575b600080fd5b60336035565b005b7fb4b2ff75e30cb4317eaae16dd8a187dd89978df17565104caa6c2797caae27d460405180604001604052806001815260200160028152506040516078919060ba565b60405180910390a1565b6040820160008201516096600085018260ad565b50602082015160a7602085018260ad565b50505050565b60b48160d3565b82525050565b600060408201905060cd60008301846082565b92915050565b600081905091905056fea26469706673582212208823628796125bf9941ce4eda18da1be3cf2931b231708ab848e1bd7151c0c9a64736f6c63430008070033"},
-		[]string{`[{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"}],"indexed":false,"internalType":"struct Test.MyStruct","name":"s","type":"tuple"}],"name":"StructEvent","type":"event"},{"inputs":[],"name":"TestEvent","outputs":[],"stateMutability":"nonpayable","type":"function"}]`},
-		`
-			"math/big"
-
-			"github.com/ethereum/go-ethereum/accounts/abi/bind"
-			"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-			"github.com/ethereum/go-ethereum/core"
-			"github.com/ethereum/go-ethereum/crypto"
-			"github.com/ethereum/go-ethereum/eth/ethconfig"
-	   `,
-		`
-			var (
-				key, _  = crypto.GenerateKey()
-				user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
-				sim     = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
-			)
-			defer sim.Close()
-
-			_, _, d, err := DeployNewSingleStructArgument(user, sim)
-			if err != nil {
-				t.Fatalf("Failed to deploy contract %v", err)
-			}
-			sim.Commit()
-
-			_, err = d.TestEvent(user)
-			if err != nil {
-				t.Fatalf("Failed to call contract %v", err)
-			}
-			sim.Commit()
-
-			it, err := d.FilterStructEvent(nil)
-			if err != nil {
-				t.Fatalf("Failed to filter contract event %v", err)
-			}
-			var count int
-			for it.Next() {
-				if it.Event.S.A.Cmp(big.NewInt(1)) != 0 {
-					t.Fatal("Unexpected contract event")
-				}
-				if it.Event.S.B.Cmp(big.NewInt(2)) != 0 {
-					t.Fatal("Unexpected contract event")
-				}
-				count += 1
-			}
-			if count != 1 {
-				t.Fatal("Unexpected contract event number")
-			}
-			`,
-		nil,
-		nil,
-		nil,
-		nil,
-	},
-	// Test errors introduced in v0.8.4
-	{
-		`NewErrors`,
-		`
-		pragma solidity >0.8.4;
-	
-		contract NewErrors {
-			error MyError(uint256);
-			error MyError1(uint256);
-			error MyError2(uint256, uint256);
-			error MyError3(uint256 a, uint256 b, uint256 c);
-			function Error() public pure {
-				revert MyError3(1,2,3);
-			}
-		}
-	   `,
-		[]string{"0x6080604052348015600f57600080fd5b5060998061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c8063726c638214602d575b600080fd5b60336035565b005b60405163024876cd60e61b815260016004820152600260248201526003604482015260640160405180910390fdfea264697066735822122093f786a1bc60216540cd999fbb4a6109e0fef20abcff6e9107fb2817ca968f3c64736f6c63430008070033"},
-		[]string{`[{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError1","type":"error"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"MyError2","type":"error"},{"inputs":[{"internalType":"uint256","name":"a","type":"uint256"},{"internalType":"uint256","name":"b","type":"uint256"},{"internalType":"uint256","name":"c","type":"uint256"}],"name":"MyError3","type":"error"},{"inputs":[],"name":"Error","outputs":[],"stateMutability":"pure","type":"function"}]`},
-		`
-			"math/big"
-	
-			"github.com/ethereum/go-ethereum/accounts/abi/bind"
-			"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-			"github.com/ethereum/go-ethereum/core"
-			"github.com/ethereum/go-ethereum/crypto"
-			"github.com/ethereum/go-ethereum/eth/ethconfig"
-	   `,
-		`
-			var (
-				key, _  = crypto.GenerateKey()
-				user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
-				sim     = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
-			)
-			defer sim.Close()
-	
-			_, tx, contract, err := DeployNewErrors(user, sim)
-			if err != nil {
-				t.Fatal(err)
-			}
-			sim.Commit()
-			_, err = bind.WaitDeployed(nil, sim, tx)
-			if err != nil {
-				t.Error(err)
-			}
-			if err := contract.Error(new(bind.CallOpts)); err == nil {
-				t.Fatalf("expected contract to throw error")
-			}
-			// TODO (MariusVanDerWijden unpack error using abigen
-			// once that is implemented
-	   `,
-		nil,
-		nil,
-		nil,
-		nil,
-	},
-	{
-		name: `ConstructorWithStructParam`,
-		contract: `
-		pragma solidity >=0.8.0 <0.9.0;
-		
-		contract ConstructorWithStructParam {
-			struct StructType {
-				uint256 field;
-			}
-		
-			constructor(StructType memory st) {}
-		}
-		`,
-		bytecode: []string{`0x608060405234801561001057600080fd5b506040516101c43803806101c48339818101604052810190610032919061014a565b50610177565b6000604051905090565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6100958261004c565b810181811067ffffffffffffffff821117156100b4576100b361005d565b5b80604052505050565b60006100c7610038565b90506100d3828261008c565b919050565b6000819050919050565b6100eb816100d8565b81146100f657600080fd5b50565b600081519050610108816100e2565b92915050565b60006020828403121561012457610123610047565b5b61012e60206100bd565b9050600061013e848285016100f9565b60008301525092915050565b6000602082840312156101605761015f610042565b5b600061016e8482850161010e565b91505092915050565b603f806101856000396000f3fe6080604052600080fdfea2646970667358221220cdffa667affecefac5561f65f4a4ba914204a8d4eb859d8cd426fb306e5c12a364736f6c634300080a0033`},
-		abi:      []string{`[{"inputs":[{"components":[{"internalType":"uint256","name":"field","type":"uint256"}],"internalType":"struct ConstructorWithStructParam.StructType","name":"st","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"}]`},
-		imports: `
-			"math/big"
-
-			"github.com/ethereum/go-ethereum/accounts/abi/bind"
-			"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
-			"github.com/ethereum/go-ethereum/core"
-			"github.com/ethereum/go-ethereum/crypto"
-			"github.com/ethereum/go-ethereum/eth/ethconfig"
-		`,
-		tester: `
-			var (
-				key, _  = crypto.GenerateKey()
-				user, _ = bind.NewKeyedTransactorWithChainID(key, big.NewInt(1337))
-				sim     = backends.NewSimulatedBackend(core.GenesisAlloc{user.From: {Balance: big.NewInt(1000000000000000000)}}, ethconfig.Defaults.Miner.GasCeil)
-			)
-			defer sim.Close()
-
-			_, tx, _, err := DeployConstructorWithStructParam(user, sim, ConstructorWithStructParamStructType{Field: big.NewInt(42)})
-			if err != nil {
-				t.Fatalf("DeployConstructorWithStructParam() got err %v; want nil err", err)
-			}
-			sim.Commit()
-			
-			if _, err = bind.WaitDeployed(nil, sim, tx); err != nil {
-				t.Logf("Deployment tx: %+v", tx)
-				t.Errorf("bind.WaitDeployed(nil, %T, <deployment tx>) got err %v; want nil err", sim, err)
-			}
-		`,
-	},
 }
 
 // Tests that packages generated by the binder can be successfully compiled and
@@ -1966,31 +1796,34 @@ func TestGolangBindings(t *testing.T) {
 		t.Skip("go sdk not found for testing")
 	}
 	// Create a temporary workspace for the test suite
-	ws := t.TempDir()
+	ws, err := ioutil.TempDir("", "binding-test")
+	if err != nil {
+		t.Fatalf("failed to create temporary workspace: %v", err)
+	}
+	//defer os.RemoveAll(ws)
 
 	pkg := filepath.Join(ws, "bindtest")
-	if err := os.MkdirAll(pkg, 0700); err != nil {
+	if err = os.MkdirAll(pkg, 0700); err != nil {
 		t.Fatalf("failed to create package: %v", err)
 	}
 	// Generate the test suite for all the contracts
 	for i, tt := range bindTests {
-		t.Run(tt.name, func(t *testing.T) {
+		var types []string
-			var types []string
+		if tt.types != nil {
-			if tt.types != nil {
+			types = tt.types
-				types = tt.types
+		} else {
-			} else {
+			types = []string{tt.name}
-				types = []string{tt.name}
+		}
-			}
+		// Generate the binding and create a Go source file in the workspace
-			// Generate the binding and create a Go source file in the workspace
+		bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", LangGo, tt.libs, tt.aliases)
-			bind, err := Bind(types, tt.abi, tt.bytecode, tt.fsigs, "bindtest", LangGo, tt.libs, tt.aliases)
+		if err != nil {
-			if err != nil {
+			t.Fatalf("test %d: failed to generate binding: %v", i, err)
-				t.Fatalf("test %d: failed to generate binding: %v", i, err)
+		}
-			}
+		if err = ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+".go"), []byte(bind), 0600); err != nil {
-			if err = ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+".go"), []byte(bind), 0600); err != nil {
+			t.Fatalf("test %d: failed to write binding: %v", i, err)
-				t.Fatalf("test %d: failed to write binding: %v", i, err)
+		}
-			}
+		// Generate the test file with the injected test code
-			// Generate the test file with the injected test code
+		code := fmt.Sprintf(`
-			code := fmt.Sprintf(`
 			package bindtest
 
 			import (
@@ -2002,10 +1835,9 @@ func TestGolangBindings(t *testing.T) {
 				%s
 			}
 		`, tt.imports, tt.name, tt.tester)
-			if err := ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+"_test.go"), []byte(code), 0600); err != nil {
+		if err := ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+"_test.go"), []byte(code), 0600); err != nil {
-				t.Fatalf("test %d: failed to write tests: %v", i, err)
+			t.Fatalf("test %d: failed to write tests: %v", i, err)
-			}
+		}
-		})
 	}
 	// Convert the package to go modules and use the current source for go-ethereum
 	moder := exec.Command(gocmd, "mod", "init", "bindtest")

accounts/abi/bind/util.go

@@ -21,7 +21,6 @@ import (
 	"errors"
 	"time"
 
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
@@ -36,16 +35,14 @@ func WaitMined(ctx context.Context, b DeployBackend, tx *types.Transaction) (*ty
 	logger := log.New("hash", tx.Hash())
 	for {
 		receipt, err := b.TransactionReceipt(ctx, tx.Hash())
-		if err == nil {
+		if receipt != nil {
 			return receipt, nil
 		}
-
+		if err != nil {
-		if errors.Is(err, ethereum.NotFound) {
-			logger.Trace("Transaction not yet mined")
-		} else {
 			logger.Trace("Receipt retrieval failed", "err", err)
+		} else {
+			logger.Trace("Transaction not yet mined")
 		}
-
 		// Wait for the next round.
 		select {
 		case <-ctx.Done():

accounts/abi/error.go

@@ -1,4 +1,4 @@
-// Copyright 2021 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
@@ -17,75 +17,66 @@
 package abi
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
-	"strings"
+	"reflect"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
 )
 
-type Error struct {
+var (
-	Name   string
+	errBadBool = errors.New("abi: improperly encoded boolean value")
-	Inputs Arguments
+)
-	str    string
+
-	// Sig contains the string signature according to the ABI spec.
+// formatSliceString formats the reflection kind with the given slice size
-	// e.g.	 event foo(uint32 a, int b) = "foo(uint32,int256)"
+// and returns a formatted string representation.
-	// Please note that "int" is substitute for its canonical representation "int256"
+func formatSliceString(kind reflect.Kind, sliceSize int) string {
-	Sig string
+	if sliceSize == -1 {
-	// ID returns the canonical representation of the event's signature used by the
+		return fmt.Sprintf("[]%v", kind)
-	// abi definition to identify event names and types.
+	}
-	ID common.Hash
+	return fmt.Sprintf("[%d]%v", sliceSize, kind)
 }
 
-func NewError(name string, inputs Arguments) Error {
+// sliceTypeCheck checks that the given slice can by assigned to the reflection
-	// sanitize inputs to remove inputs without names
+// type in t.
-	// and precompute string and sig representation.
+func sliceTypeCheck(t Type, val reflect.Value) error {
-	names := make([]string, len(inputs))
+	if val.Kind() != reflect.Slice && val.Kind() != reflect.Array {
-	types := make([]string, len(inputs))
+		return typeErr(formatSliceString(t.GetType().Kind(), t.Size), val.Type())
-	for i, input := range inputs {
+	}
-		if input.Name == "" {
+
-			inputs[i] = Argument{
+	if t.T == ArrayTy && val.Len() != t.Size {
-				Name:    fmt.Sprintf("arg%d", i),
+		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len()))
-				Indexed: input.Indexed,
+	}
-				Type:    input.Type,
+
-			}
+	if t.Elem.T == SliceTy || t.Elem.T == ArrayTy {
-		} else {
+		if val.Len() > 0 {
-			inputs[i] = input
+			return sliceTypeCheck(*t.Elem, val.Index(0))
 		}
-		// 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("error %v(%v)", name, strings.Join(names, ", "))
+	if val.Type().Elem().Kind() != t.Elem.GetType().Kind() {
-	sig := fmt.Sprintf("%v(%v)", name, strings.Join(types, ","))
+		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), val.Type())
-	id := common.BytesToHash(crypto.Keccak256([]byte(sig)))
-
-	return Error{
-		Name:   name,
-		Inputs: inputs,
-		str:    str,
-		Sig:    sig,
-		ID:     id,
 	}
+	return nil
 }
 
-func (e *Error) String() string {
+// typeCheck checks that the given reflection value can be assigned to the reflection
-	return e.str
+// type in t.
+func typeCheck(t Type, value reflect.Value) error {
+	if t.T == SliceTy || t.T == ArrayTy {
+		return sliceTypeCheck(t, value)
+	}
+
+	// Check base type validity. Element types will be checked later on.
+	if t.GetType().Kind() != value.Kind() {
+		return typeErr(t.GetType().Kind(), value.Kind())
+	} else if t.T == FixedBytesTy && t.Size != value.Len() {
+		return typeErr(t.GetType(), value.Type())
+	} else {
+		return nil
+	}
+
 }
 
-func (e *Error) Unpack(data []byte) (interface{}, error) {
+// typeErr returns a formatted type casting error.
-	if len(data) < 4 {
+func typeErr(expected, got interface{}) error {
-		return "", errors.New("invalid data for unpacking")
+	return fmt.Errorf("abi: cannot use %v as type %v as argument", got, expected)
-	}
-	if !bytes.Equal(data[:4], e.ID[:4]) {
-		return "", errors.New("invalid data for unpacking")
-	}
-	return e.Inputs.Unpack(data[4:])
 }

accounts/abi/error_handling.go

@@ -1,82 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package abi
-
-import (
-	"errors"
-	"fmt"
-	"reflect"
-)
-
-var (
-	errBadBool = errors.New("abi: improperly encoded boolean value")
-)
-
-// formatSliceString formats the reflection kind with the given slice size
-// and returns a formatted string representation.
-func formatSliceString(kind reflect.Kind, sliceSize int) string {
-	if sliceSize == -1 {
-		return fmt.Sprintf("[]%v", kind)
-	}
-	return fmt.Sprintf("[%d]%v", sliceSize, kind)
-}
-
-// sliceTypeCheck checks that the given slice can by assigned to the reflection
-// 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())
-	}
-
-	if t.T == ArrayTy && val.Len() != t.Size {
-		return typeErr(formatSliceString(t.Elem.GetType().Kind(), t.Size), formatSliceString(val.Type().Elem().Kind(), val.Len()))
-	}
-
-	if t.Elem.T == SliceTy || t.Elem.T == ArrayTy {
-		if val.Len() > 0 {
-			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())
-	}
-	return nil
-}
-
-// typeCheck checks that the given reflection value can be assigned to the reflection
-// type in t.
-func typeCheck(t Type, value reflect.Value) error {
-	if t.T == SliceTy || t.T == ArrayTy {
-		return sliceTypeCheck(t, value)
-	}
-
-	// Check base type validity. Element types will be checked later on.
-	if t.GetType().Kind() != value.Kind() {
-		return typeErr(t.GetType().Kind(), value.Kind())
-	} else if t.T == FixedBytesTy && t.Size != value.Len() {
-		return typeErr(t.GetType(), value.Type())
-	} else {
-		return nil
-	}
-
-}
-
-// typeErr returns a formatted type casting error.
-func typeErr(expected, got interface{}) error {
-	return fmt.Errorf("abi: cannot use %v as type %v as argument", got, expected)
-}

accounts/abi/reflect.go

@@ -123,8 +123,15 @@ func set(dst, src reflect.Value) error {
 func setSlice(dst, src reflect.Value) error {
 	slice := reflect.MakeSlice(dst.Type(), src.Len(), src.Len())
 	for i := 0; i < src.Len(); i++ {
-		if err := set(slice.Index(i), src.Index(i)); err != nil {
+		if src.Index(i).Kind() == reflect.Struct {
-			return err
+			if err := set(slice.Index(i), src.Index(i)); err != nil {
+				return err
+			}
+		} else {
+			// e.g. [][32]uint8 to []common.Hash
+			if err := set(slice.Index(i), src.Index(i)); err != nil {
+				return err
+			}
 		}
 	}
 	if dst.CanSet() {

accounts/abi/selector_parser.go

@@ -1,160 +0,0 @@
-package abi
-
-import (
-	"fmt"
-)
-
-type SelectorMarshaling struct {
-	Name   string               `json:"name"`
-	Type   string               `json:"type"`
-	Inputs []ArgumentMarshaling `json:"inputs"`
-}
-
-func isDigit(c byte) bool {
-	return c >= '0' && c <= '9'
-}
-
-func isAlpha(c byte) bool {
-	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
-}
-
-func isIdentifierSymbol(c byte) bool {
-	return c == '$' || c == '_'
-}
-
-func parseToken(unescapedSelector string, isIdent bool) (string, string, error) {
-	if len(unescapedSelector) == 0 {
-		return "", "", fmt.Errorf("empty token")
-	}
-	firstChar := unescapedSelector[0]
-	position := 1
-	if !(isAlpha(firstChar) || (isIdent && isIdentifierSymbol(firstChar))) {
-		return "", "", fmt.Errorf("invalid token start: %c", firstChar)
-	}
-	for position < len(unescapedSelector) {
-		char := unescapedSelector[position]
-		if !(isAlpha(char) || isDigit(char) || (isIdent && isIdentifierSymbol(char))) {
-			break
-		}
-		position++
-	}
-	return unescapedSelector[:position], unescapedSelector[position:], nil
-}
-
-func parseIdentifier(unescapedSelector string) (string, string, error) {
-	return parseToken(unescapedSelector, true)
-}
-
-func parseElementaryType(unescapedSelector string) (string, string, error) {
-	parsedType, rest, err := parseToken(unescapedSelector, false)
-	if err != nil {
-		return "", "", fmt.Errorf("failed to parse elementary type: %v", err)
-	}
-	// handle arrays
-	for len(rest) > 0 && rest[0] == '[' {
-		parsedType = parsedType + string(rest[0])
-		rest = rest[1:]
-		for len(rest) > 0 && isDigit(rest[0]) {
-			parsedType = parsedType + string(rest[0])
-			rest = rest[1:]
-		}
-		if len(rest) == 0 || rest[0] != ']' {
-			return "", "", fmt.Errorf("failed to parse array: expected ']', got %c", unescapedSelector[0])
-		}
-		parsedType = parsedType + string(rest[0])
-		rest = rest[1:]
-	}
-	return parsedType, rest, nil
-}
-
-func parseCompositeType(unescapedSelector string) ([]interface{}, string, error) {
-	if len(unescapedSelector) == 0 || unescapedSelector[0] != '(' {
-		return nil, "", fmt.Errorf("expected '(', got %c", unescapedSelector[0])
-	}
-	parsedType, rest, err := parseType(unescapedSelector[1:])
-	if err != nil {
-		return nil, "", fmt.Errorf("failed to parse type: %v", err)
-	}
-	result := []interface{}{parsedType}
-	for len(rest) > 0 && rest[0] != ')' {
-		parsedType, rest, err = parseType(rest[1:])
-		if err != nil {
-			return nil, "", fmt.Errorf("failed to parse type: %v", err)
-		}
-		result = append(result, parsedType)
-	}
-	if len(rest) == 0 || rest[0] != ')' {
-		return nil, "", fmt.Errorf("expected ')', got '%s'", rest)
-	}
-	if len(rest) >= 3 && rest[1] == '[' && rest[2] == ']' {
-		return append(result, "[]"), rest[3:], nil
-	}
-	return result, rest[1:], nil
-}
-
-func parseType(unescapedSelector string) (interface{}, string, error) {
-	if len(unescapedSelector) == 0 {
-		return nil, "", fmt.Errorf("empty type")
-	}
-	if unescapedSelector[0] == '(' {
-		return parseCompositeType(unescapedSelector)
-	} else {
-		return parseElementaryType(unescapedSelector)
-	}
-}
-
-func assembleArgs(args []interface{}) ([]ArgumentMarshaling, error) {
-	arguments := make([]ArgumentMarshaling, 0)
-	for i, arg := range args {
-		// generate dummy name to avoid unmarshal issues
-		name := fmt.Sprintf("name%d", i)
-		if s, ok := arg.(string); ok {
-			arguments = append(arguments, ArgumentMarshaling{name, s, s, nil, false})
-		} else if components, ok := arg.([]interface{}); ok {
-			subArgs, err := assembleArgs(components)
-			if err != nil {
-				return nil, fmt.Errorf("failed to assemble components: %v", err)
-			}
-			tupleType := "tuple"
-			if len(subArgs) != 0 && subArgs[len(subArgs)-1].Type == "[]" {
-				subArgs = subArgs[:len(subArgs)-1]
-				tupleType = "tuple[]"
-			}
-			arguments = append(arguments, ArgumentMarshaling{name, tupleType, tupleType, subArgs, false})
-		} else {
-			return nil, fmt.Errorf("failed to assemble args: unexpected type %T", arg)
-		}
-	}
-	return arguments, nil
-}
-
-// ParseSelector converts a method selector into a struct that can be JSON encoded
-// and consumed by other functions in this package.
-// Note, although uppercase letters are not part of the ABI spec, this function
-// still accepts it as the general format is valid.
-func ParseSelector(unescapedSelector string) (SelectorMarshaling, error) {
-	name, rest, err := parseIdentifier(unescapedSelector)
-	if err != nil {
-		return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': %v", unescapedSelector, err)
-	}
-	args := []interface{}{}
-	if len(rest) >= 2 && rest[0] == '(' && rest[1] == ')' {
-		rest = rest[2:]
-	} else {
-		args, rest, err = parseCompositeType(rest)
-		if err != nil {
-			return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': %v", unescapedSelector, err)
-		}
-	}
-	if len(rest) > 0 {
-		return SelectorMarshaling{}, fmt.Errorf("failed to parse selector '%s': unexpected string '%s'", unescapedSelector, rest)
-	}
-
-	// Reassemble the fake ABI and constuct the JSON
-	fakeArgs, err := assembleArgs(args)
-	if err != nil {
-		return SelectorMarshaling{}, fmt.Errorf("failed to parse selector: %v", err)
-	}
-
-	return SelectorMarshaling{name, "function", fakeArgs}, nil
-}

accounts/abi/selector_parser_test.go

@@ -1,63 +0,0 @@
-package abi
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"testing"
-)
-
-func TestParseSelector(t *testing.T) {
-	mkType := func(types ...interface{}) []ArgumentMarshaling {
-		var result []ArgumentMarshaling
-		for i, typeOrComponents := range types {
-			name := fmt.Sprintf("name%d", i)
-			if typeName, ok := typeOrComponents.(string); ok {
-				result = append(result, ArgumentMarshaling{name, typeName, typeName, nil, false})
-			} else if components, ok := typeOrComponents.([]ArgumentMarshaling); ok {
-				result = append(result, ArgumentMarshaling{name, "tuple", "tuple", components, false})
-			} else if components, ok := typeOrComponents.([][]ArgumentMarshaling); ok {
-				result = append(result, ArgumentMarshaling{name, "tuple[]", "tuple[]", components[0], false})
-			} else {
-				log.Fatalf("unexpected type %T", typeOrComponents)
-			}
-		}
-		return result
-	}
-	tests := []struct {
-		input string
-		name  string
-		args  []ArgumentMarshaling
-	}{
-		{"noargs()", "noargs", []ArgumentMarshaling{}},
-		{"simple(uint256,uint256,uint256)", "simple", mkType("uint256", "uint256", "uint256")},
-		{"other(uint256,address)", "other", mkType("uint256", "address")},
-		{"withArray(uint256[],address[2],uint8[4][][5])", "withArray", mkType("uint256[]", "address[2]", "uint8[4][][5]")},
-		{"singleNest(bytes32,uint8,(uint256,uint256),address)", "singleNest", mkType("bytes32", "uint8", mkType("uint256", "uint256"), "address")},
-		{"multiNest(address,(uint256[],uint256),((address,bytes32),uint256))", "multiNest",
-			mkType("address", mkType("uint256[]", "uint256"), mkType(mkType("address", "bytes32"), "uint256"))},
-		{"arrayNest((uint256,uint256)[],bytes32)", "arrayNest", mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, "bytes32")},
-		{"multiArrayNest((uint256,uint256)[],(uint256,uint256)[])", "multiArrayNest",
-			mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, [][]ArgumentMarshaling{mkType("uint256", "uint256")})},
-		{"singleArrayNestAndArray((uint256,uint256)[],bytes32[])", "singleArrayNestAndArray",
-			mkType([][]ArgumentMarshaling{mkType("uint256", "uint256")}, "bytes32[]")},
-		{"singleArrayNestWithArrayAndArray((uint256[],address[2],uint8[4][][5])[],bytes32[])", "singleArrayNestWithArrayAndArray",
-			mkType([][]ArgumentMarshaling{mkType("uint256[]", "address[2]", "uint8[4][][5]")}, "bytes32[]")},
-	}
-	for i, tt := range tests {
-		selector, err := ParseSelector(tt.input)
-		if err != nil {
-			t.Errorf("test %d: failed to parse selector '%v': %v", i, tt.input, err)
-		}
-		if selector.Name != tt.name {
-			t.Errorf("test %d: unexpected function name: '%s' != '%s'", i, selector.Name, tt.name)
-		}
-
-		if selector.Type != "function" {
-			t.Errorf("test %d: unexpected type: '%s' != '%s'", i, selector.Type, "function")
-		}
-		if !reflect.DeepEqual(selector.Inputs, tt.args) {
-			t.Errorf("test %d: unexpected args: '%v' != '%v'", i, selector.Inputs, tt.args)
-		}
-	}
-}

accounts/abi/unpack.go

@@ -290,7 +290,7 @@ func tuplePointsTo(index int, output []byte) (start int, err error) {
 	offset := big.NewInt(0).SetBytes(output[index : index+32])
 	outputLen := big.NewInt(int64(len(output)))
 
-	if offset.Cmp(outputLen) > 0 {
+	if offset.Cmp(big.NewInt(int64(len(output)))) > 0 {
 		return 0, fmt.Errorf("abi: cannot marshal in to go slice: offset %v would go over slice boundary (len=%v)", offset, outputLen)
 	}
 	if offset.BitLen() > 63 {

accounts/abi/unpack_test.go

@@ -762,24 +762,20 @@ func TestUnpackTuple(t *testing.T) {
 	buff.Write(common.Hex2Bytes("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) // ret[b] = -1
 
 	// If the result is single tuple, use struct as return value container directly.
-	type v struct {
+	v := struct {
 		A *big.Int
 		B *big.Int
-	}
+	}{new(big.Int), new(big.Int)}
-	type r struct {
-		Result v
-	}
-	var ret0 = new(r)
-	err = abi.UnpackIntoInterface(ret0, "tuple", buff.Bytes())
 
+	err = abi.UnpackIntoInterface(&v, "tuple", buff.Bytes())
 	if err != nil {
 		t.Error(err)
 	} else {
-		if ret0.Result.A.Cmp(big.NewInt(1)) != 0 {
+		if v.A.Cmp(big.NewInt(1)) != 0 {
-			t.Errorf("unexpected value unpacked: want %x, got %x", 1, ret0.Result.A)
+			t.Errorf("unexpected value unpacked: want %x, got %x", 1, v.A)
 		}
-		if ret0.Result.B.Cmp(big.NewInt(-1)) != 0 {
+		if v.B.Cmp(big.NewInt(-1)) != 0 {
-			t.Errorf("unexpected value unpacked: want %x, got %x", -1, ret0.Result.B)
+			t.Errorf("unexpected value unpacked: want %x, got %x", -1, v.B)
 		}
 	}
 

accounts/accounts.go

@@ -46,7 +46,7 @@ const (
 // accounts (derived from the same seed).
 type Wallet interface {
 	// URL retrieves the canonical path under which this wallet is reachable. It is
-	// used by upper layers to define a sorting order over all wallets from multiple
+	// user by upper layers to define a sorting order over all wallets from multiple
 	// backends.
 	URL() URL
 
@@ -89,7 +89,7 @@ type Wallet interface {
 	// accounts.
 	//
 	// Note, self derivation will increment the last component of the specified path
-	// opposed to descending into a child path to allow discovering accounts starting
+	// 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
@@ -105,7 +105,7 @@ type Wallet interface {
 	// or optionally with the aid of any location metadata from the embedded URL field.
 	//
 	// If the wallet requires additional authentication to sign the request (e.g.
-	// a password to decrypt the account, or a PIN code to verify the transaction),
+	// 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
@@ -124,13 +124,13 @@ type Wallet interface {
 	// or optionally with the aid of any location metadata from the embedded URL field.
 	//
 	// If the wallet requires additional authentication to sign the request (e.g.
-	// a password to decrypt the account, or a PIN code to verify the transaction),
+	// 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 SignTextWithPassphrase, 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.
+	// 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
@@ -176,7 +176,7 @@ type Backend interface {
 // 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 calculated as
+// 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.
@@ -188,7 +188,7 @@ func TextHash(data []byte) []byte {
 // 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 calculated as
+// 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.

accounts/errors.go

@@ -42,7 +42,7 @@ var ErrInvalidPassphrase = errors.New("invalid password")
 var ErrWalletAlreadyOpen = errors.New("wallet already open")
 
 // ErrWalletClosed is returned if a wallet is attempted to be opened the
-// second time.
+// secodn time.
 var ErrWalletClosed = errors.New("wallet closed")
 
 // AuthNeededError is returned by backends for signing requests where the user

accounts/keystore/account_cache_test.go

@@ -55,6 +55,7 @@ func TestWatchNewFile(t *testing.T) {
 	t.Parallel()
 
 	dir, ks := tmpKeyStore(t, false)
+	defer os.RemoveAll(dir)
 
 	// Ensure the watcher is started before adding any files.
 	ks.Accounts()
@@ -95,7 +96,7 @@ func TestWatchNoDir(t *testing.T) {
 
 	// Create ks but not the directory that it watches.
 	rand.Seed(time.Now().UnixNano())
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watchnodir-test-%d-%d", os.Getpid(), rand.Int()))
+	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watch-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
 
 	list := ks.Accounts()
@@ -321,7 +322,7 @@ func TestUpdatedKeyfileContents(t *testing.T) {
 
 	// Create a temporary kesytore to test with
 	rand.Seed(time.Now().UnixNano())
-	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-updatedkeyfilecontents-test-%d-%d", os.Getpid(), rand.Int()))
+	dir := filepath.Join(os.TempDir(), fmt.Sprintf("eth-keystore-watch-test-%d-%d", os.Getpid(), rand.Int()))
 	ks := NewKeyStore(dir, LightScryptN, LightScryptP)
 
 	list := ks.Accounts()

accounts/keystore/keystore_test.go

@@ -17,6 +17,7 @@
 package keystore
 
 import (
+	"io/ioutil"
 	"math/rand"
 	"os"
 	"runtime"
@@ -37,6 +38,7 @@ var testSigData = make([]byte, 32)
 
 func TestKeyStore(t *testing.T) {
 	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
 
 	a, err := ks.NewAccount("foo")
 	if err != nil {
@@ -70,7 +72,8 @@ func TestKeyStore(t *testing.T) {
 }
 
 func TestSign(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
 
 	pass := "" // not used but required by API
 	a1, err := ks.NewAccount(pass)
@@ -86,7 +89,8 @@ func TestSign(t *testing.T) {
 }
 
 func TestSignWithPassphrase(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
 
 	pass := "passwd"
 	acc, err := ks.NewAccount(pass)
@@ -113,7 +117,8 @@ func TestSignWithPassphrase(t *testing.T) {
 }
 
 func TestTimedUnlock(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
 
 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@@ -147,7 +152,8 @@ func TestTimedUnlock(t *testing.T) {
 }
 
 func TestOverrideUnlock(t *testing.T) {
-	_, ks := tmpKeyStore(t, false)
+	dir, ks := tmpKeyStore(t, false)
+	defer os.RemoveAll(dir)
 
 	pass := "foo"
 	a1, err := ks.NewAccount(pass)
@@ -187,7 +193,8 @@ func TestOverrideUnlock(t *testing.T) {
 
 // This test should fail under -race if signing races the expiration goroutine.
 func TestSignRace(t *testing.T) {
-	_, ks := tmpKeyStore(t, false)
+	dir, ks := tmpKeyStore(t, false)
+	defer os.RemoveAll(dir)
 
 	// Create a test account.
 	a1, err := ks.NewAccount("")
@@ -215,7 +222,8 @@ func TestSignRace(t *testing.T) {
 // addition and removal of wallet event subscriptions.
 func TestWalletNotifierLifecycle(t *testing.T) {
 	// Create a temporary kesytore to test with
-	_, ks := tmpKeyStore(t, false)
+	dir, ks := tmpKeyStore(t, false)
+	defer os.RemoveAll(dir)
 
 	// Ensure that the notification updater is not running yet
 	time.Sleep(250 * time.Millisecond)
@@ -275,7 +283,8 @@ type walletEvent struct {
 // Tests that wallet notifications and correctly fired when accounts are added
 // or deleted from the keystore.
 func TestWalletNotifications(t *testing.T) {
-	_, ks := tmpKeyStore(t, false)
+	dir, ks := tmpKeyStore(t, false)
+	defer os.RemoveAll(dir)
 
 	// Subscribe to the wallet feed and collect events.
 	var (
@@ -336,7 +345,8 @@ func TestWalletNotifications(t *testing.T) {
 
 // TestImportExport tests the import functionality of a keystore.
 func TestImportECDSA(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	dir, ks := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir)
 	key, err := crypto.GenerateKey()
 	if err != nil {
 		t.Fatalf("failed to generate key: %v", key)
@@ -354,7 +364,8 @@ func TestImportECDSA(t *testing.T) {
 
 // TestImportECDSA tests the import and export functionality of a keystore.
 func TestImportExport(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	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)
@@ -363,7 +374,8 @@ func TestImportExport(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t, true)
+	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")
 	}
@@ -383,7 +395,8 @@ func TestImportExport(t *testing.T) {
 // TestImportRace tests the keystore on races.
 // This test should fail under -race if importing races.
 func TestImportRace(t *testing.T) {
-	_, ks := tmpKeyStore(t, true)
+	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)
@@ -392,7 +405,8 @@ func TestImportRace(t *testing.T) {
 	if err != nil {
 		t.Fatalf("failed to export account: %v", acc)
 	}
-	_, ks2 := tmpKeyStore(t, true)
+	dir2, ks2 := tmpKeyStore(t, true)
+	defer os.RemoveAll(dir2)
 	var atom uint32
 	var wg sync.WaitGroup
 	wg.Add(2)
@@ -448,7 +462,10 @@ func checkEvents(t *testing.T, want []walletEvent, have []walletEvent) {
 }
 
 func tmpKeyStore(t *testing.T, encrypted bool) (string, *KeyStore) {
-	d := t.TempDir()
+	d, err := ioutil.TempDir("", "eth-keystore-test")
+	if err != nil {
+		t.Fatal(err)
+	}
 	newKs := NewPlaintextKeyStore
 	if encrypted {
 		newKs = func(kd string) *KeyStore { return NewKeyStore(kd, veryLightScryptN, veryLightScryptP) }

accounts/keystore/plain_test.go

@@ -20,6 +20,8 @@ import (
 	"crypto/rand"
 	"encoding/hex"
 	"fmt"
+	"io/ioutil"
+	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
@@ -30,7 +32,10 @@ import (
 )
 
 func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
-	d := t.TempDir()
+	d, err := ioutil.TempDir("", "geth-keystore-test")
+	if err != nil {
+		t.Fatal(err)
+	}
 	if encrypted {
 		ks = &keyStorePassphrase{d, veryLightScryptN, veryLightScryptP, true}
 	} else {
@@ -40,7 +45,8 @@ func tmpKeyStoreIface(t *testing.T, encrypted bool) (dir string, ks keyStore) {
 }
 
 func TestKeyStorePlain(t *testing.T) {
-	_, ks := tmpKeyStoreIface(t, false)
+	dir, ks := tmpKeyStoreIface(t, false)
+	defer os.RemoveAll(dir)
 
 	pass := "" // not used but required by API
 	k1, account, err := storeNewKey(ks, rand.Reader, pass)
@@ -60,7 +66,8 @@ func TestKeyStorePlain(t *testing.T) {
 }
 
 func TestKeyStorePassphrase(t *testing.T) {
-	_, ks := tmpKeyStoreIface(t, true)
+	dir, ks := tmpKeyStoreIface(t, true)
+	defer os.RemoveAll(dir)
 
 	pass := "foo"
 	k1, account, err := storeNewKey(ks, rand.Reader, pass)
@@ -80,7 +87,8 @@ func TestKeyStorePassphrase(t *testing.T) {
 }
 
 func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
-	_, ks := tmpKeyStoreIface(t, true)
+	dir, ks := tmpKeyStoreIface(t, true)
+	defer os.RemoveAll(dir)
 
 	pass := "foo"
 	k1, account, err := storeNewKey(ks, rand.Reader, pass)
@@ -94,6 +102,7 @@ func TestKeyStorePassphraseDecryptionFail(t *testing.T) {
 
 func TestImportPreSaleKey(t *testing.T) {
 	dir, ks := tmpKeyStoreIface(t, true)
+	defer os.RemoveAll(dir)
 
 	// file content of a presale key file generated with:
 	// python pyethsaletool.py genwallet

accounts/keystore/watch.go

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

accounts/keystore/watch_fallback.go

@@ -14,7 +14,6 @@
 // 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/>.
 
-//go:build (darwin && !cgo) || ios || (linux && arm64) || windows || (!darwin && !freebsd && !linux && !netbsd && !solaris)
 // +build darwin,!cgo ios linux,arm64 windows !darwin,!freebsd,!linux,!netbsd,!solaris
 
 // This is the fallback implementation of directory watching.

accounts/manager.go

@@ -25,10 +25,6 @@ import (
 	"github.com/ethereum/go-ethereum/event"
 )
 
-// managerSubBufferSize determines how many incoming wallet events
-// the manager will buffer in its channel.
-const managerSubBufferSize = 50
-
 // Config contains the settings of the global account manager.
 //
 // TODO(rjl493456442, karalabe, holiman): Get rid of this when account management
@@ -37,27 +33,18 @@ type Config struct {
 	InsecureUnlockAllowed bool // Whether account unlocking in insecure environment is allowed
 }
 
-// newBackendEvent lets the manager know it should
-// track the given backend for wallet updates.
-type newBackendEvent struct {
-	backend   Backend
-	processed chan struct{} // Informs event emitter that backend has been integrated
-}
-
 // Manager is an overarching account manager that can communicate with various
 // backends for signing transactions.
 type Manager struct {
-	config      *Config                    // Global account manager configurations
+	config   *Config                    // Global account manager configurations
-	backends    map[reflect.Type][]Backend // Index of backends currently registered
+	backends map[reflect.Type][]Backend // Index of backends currently registered
-	updaters    []event.Subscription       // Wallet update subscriptions for all backends
+	updaters []event.Subscription       // Wallet update subscriptions for all backends
-	updates     chan WalletEvent           // Subscription sink for backend wallet changes
+	updates  chan WalletEvent           // Subscription sink for backend wallet changes
-	newBackends chan newBackendEvent       // Incoming backends to be tracked by the manager
+	wallets  []Wallet                   // Cache of all wallets from all registered backends
-	wallets     []Wallet                   // Cache of all wallets from all registered backends
 
 	feed event.Feed // Wallet feed notifying of arrivals/departures
 
 	quit chan chan error
-	term chan struct{} // Channel is closed upon termination of the update loop
 	lock sync.RWMutex
 }
 
@@ -70,7 +57,7 @@ func NewManager(config *Config, backends ...Backend) *Manager {
 		wallets = merge(wallets, backend.Wallets()...)
 	}
 	// Subscribe to wallet notifications from all backends
-	updates := make(chan WalletEvent, managerSubBufferSize)
+	updates := make(chan WalletEvent, 4*len(backends))
 
 	subs := make([]event.Subscription, len(backends))
 	for i, backend := range backends {
@@ -78,14 +65,12 @@ func NewManager(config *Config, backends ...Backend) *Manager {
 	}
 	// Assemble the account manager and return
 	am := &Manager{
-		config:      config,
+		config:   config,
-		backends:    make(map[reflect.Type][]Backend),
+		backends: make(map[reflect.Type][]Backend),
-		updaters:    subs,
+		updaters: subs,
-		updates:     updates,
+		updates:  updates,
-		newBackends: make(chan newBackendEvent),
+		wallets:  wallets,
-		wallets:     wallets,
+		quit:     make(chan chan error),
-		quit:        make(chan chan error),
-		term:        make(chan struct{}),
 	}
 	for _, backend := range backends {
 		kind := reflect.TypeOf(backend)
@@ -108,14 +93,6 @@ func (am *Manager) Config() *Config {
 	return am.config
 }
 
-// AddBackend starts the tracking of an additional backend for wallet updates.
-// cmd/geth assumes once this func returns the backends have been already integrated.
-func (am *Manager) AddBackend(backend Backend) {
-	done := make(chan struct{})
-	am.newBackends <- newBackendEvent{backend, done}
-	<-done
-}
-
 // update is the wallet event loop listening for notifications from the backends
 // and updating the cache of wallets.
 func (am *Manager) update() {
@@ -145,22 +122,10 @@ func (am *Manager) update() {
 
 			// Notify any listeners of the event
 			am.feed.Send(event)
-		case event := <-am.newBackends:
+
-			am.lock.Lock()
-			// Update caches
-			backend := event.backend
-			am.wallets = merge(am.wallets, backend.Wallets()...)
-			am.updaters = append(am.updaters, backend.Subscribe(am.updates))
-			kind := reflect.TypeOf(backend)
-			am.backends[kind] = append(am.backends[kind], backend)
-			am.lock.Unlock()
-			close(event.processed)
 		case errc := <-am.quit:
 			// Manager terminating, return
 			errc <- nil
-			// Signals event emitters the loop is not receiving values
-			// to prevent them from getting stuck.
-			close(am.term)
 			return
 		}
 	}
@@ -168,9 +133,6 @@ func (am *Manager) update() {
 
 // Backends retrieves the backend(s) with the given type from the account manager.
 func (am *Manager) Backends(kind reflect.Type) []Backend {
-	am.lock.RLock()
-	defer am.lock.RUnlock()
-
 	return am.backends[kind]
 }
 

accounts/scwallet/wallet.go

@@ -638,7 +638,7 @@ func (w *Wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Accoun
 // accounts.
 //
 // Note, self derivation will increment the last component of the specified path
-// opposed to descending into a child path to allow discovering accounts starting
+// 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

accounts/usbwallet/wallet.go

@@ -496,7 +496,7 @@ func (w *wallet) Derive(path accounts.DerivationPath, pin bool) (accounts.Accoun
 // accounts.
 //
 // Note, self derivation will increment the last component of the specified path
-// opposed to descending into a child path to allow discovering accounts starting
+// 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

appveyor.yml

@@ -1,57 +1,29 @@
+os: Visual Studio 2019
 clone_depth: 5
 version: "{branch}.{build}"
-
-image:
-  - Ubuntu
-  - Visual Studio 2019
-
 environment:
   matrix:
+    # We use gcc from MSYS2 because it is the most recent compiler version available on
+    # AppVeyor. Note: gcc.exe only works properly if the corresponding bin/ directory is
+    # contained in PATH.
     - GETH_ARCH: amd64
-      GETH_MINGW: 'C:\msys64\mingw64'
+      GETH_CC: C:\msys64\mingw64\bin\gcc.exe
+      PATH: C:\msys64\mingw64\bin;C:\Program Files (x86)\NSIS\;%PATH%
     - GETH_ARCH: 386
-      GETH_MINGW: 'C:\msys64\mingw32'
+      GETH_CC: C:\msys64\mingw32\bin\gcc.exe
+      PATH: C:\msys64\mingw32\bin;C:\Program Files (x86)\NSIS\;%PATH%
 
 install:
-  - git submodule update --init --depth 1 --recursive
+  - git submodule update --init --depth 1
   - go version
+  - "%GETH_CC% --version"
 
-for:
+build_script:
-  # Linux has its own script without -arch and -cc.
+  - go run build\ci.go install -dlgo -arch %GETH_ARCH% -cc %GETH_CC%
-  # The linux builder also runs lint.
-  - matrix:
-      only:
-        - image: Ubuntu
-    build_script:
-      - go run build/ci.go lint
-      - go run build/ci.go install -dlgo
-    test_script:
-      - go run build/ci.go test -dlgo -coverage
 
-  # linux/386 is disabled.
+after_build:
-  - matrix:
+  - go run build\ci.go archive -arch %GETH_ARCH% -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
-      exclude:
+  - go run build\ci.go nsis -arch %GETH_ARCH% -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
-        - image: Ubuntu
-          GETH_ARCH: 386
 
-  # Windows builds for amd64 + 386.
+test_script:
-  - matrix:
+  - go run build\ci.go test -dlgo -arch %GETH_ARCH% -cc %GETH_CC% -coverage
-      only:
-        - image: Visual Studio 2019
-    environment:
-      # We use gcc from MSYS2 because it is the most recent compiler version available on
-      # AppVeyor. Note: gcc.exe only works properly if the corresponding bin/ directory is
-      # contained in PATH.
-      GETH_CC: '%GETH_MINGW%\bin\gcc.exe'
-      PATH: '%GETH_MINGW%\bin;C:\Program Files (x86)\NSIS\;%PATH%'
-    build_script:
-      - 'echo %GETH_ARCH%'
-      - 'echo %GETH_CC%'
-      - '%GETH_CC% --version'
-      - go run build/ci.go install -dlgo -arch %GETH_ARCH% -cc %GETH_CC%
-    after_build:
-      # Upload builds. Note that ci.go makes this a no-op PR builds.
-      - go run build/ci.go archive -arch %GETH_ARCH% -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
-      - go run build/ci.go nsis -arch %GETH_ARCH% -signer WINDOWS_SIGNING_KEY -upload gethstore/builds
-    test_script:
-      - go run build/ci.go test -dlgo -arch %GETH_ARCH% -cc %GETH_CC% -coverage

build/checksums.txt

@@ -1,58 +1,33 @@
 # This file contains sha256 checksums of optional build dependencies.
 
-efd43e0f1402e083b73a03d444b7b6576bb4c539ac46208b63a916b69aca4088  go1.18.1.src.tar.gz
+ae4f6b6e2a1677d31817984655a762074b5356da50fb58722b99104870d43503  go1.16.4.src.tar.gz
-3703e9a0db1000f18c0c7b524f3d378aac71219b4715a6a4c5683eb639f41a4d  go1.18.1.darwin-amd64.tar.gz
+18fe94775763db3878717393b6d41371b0b45206055e49b3838328120c977d13  go1.16.4.darwin-amd64.tar.gz
-6d5641a06edba8cd6d425fb0adad06bad80e2afe0fa91b4aa0e5aed1bc78f58e  go1.18.1.darwin-arm64.tar.gz
+cb6b972cc42e669f3585c648198cd5b6f6d7a0811d413ad64b50c02ba06ccc3a  go1.16.4.darwin-arm64.tar.gz
-b9a9063d4265d8ccc046c9b314194d6eadc47e56d0d637db81e98e68aad45035  go1.18.1.freebsd-386.tar.gz
+cd1b146ef6e9006f27dd99e9687773e7fef30e8c985b7d41bff33e955a3bb53a  go1.16.4.linux-386.tar.gz
-2bc1c138d645e37dbbc63517dd1cf1bf33fc4cb95f442a6384df0418b5134e9f  go1.18.1.freebsd-amd64.tar.gz
+7154e88f5a8047aad4b80ebace58a059e36e7e2e4eb3b383127a28c711b4ff59  go1.16.4.linux-amd64.tar.gz
-9a8df5dde9058f08ac01ecfaae42534610db398e487138788c01da26a0d41ff9  go1.18.1.linux-386.tar.gz
+8b18eb05ddda2652d69ab1b1dd1f40dd731799f43c6a58b512ad01ae5b5bba21  go1.16.4.linux-arm64.tar.gz
-b3b815f47ababac13810fc6021eb73d65478e0b2db4b09d348eefad9581a2334  go1.18.1.linux-amd64.tar.gz
+a53391a800ddec749ee90d38992babb27b95cfb864027350c737b9aa8e069494  go1.16.4.linux-armv6l.tar.gz
-56a91851c97fb4697077abbca38860f735c32b38993ff79b088dac46e4735633  go1.18.1.linux-arm64.tar.gz
+e75c0b114a09eb5499874162b208931dc260de0fedaeedac8621bf263c974605  go1.16.4.windows-386.zip
-9edc01c8e7db64e9ceeffc8258359e027812886ceca3444e83c4eb96ddb068ee  go1.18.1.linux-armv6l.tar.gz
+d40139b7ade8a3008e3240a6f86fe8f899a9c465c917e11dac8758af216f5eb0  go1.16.4.windows-amd64.zip
-33db623d1eecf362fe365107c12efc90eff0b9609e0b3345e258388019cb552a  go1.18.1.linux-ppc64le.tar.gz
+7cf2bc8a175d6d656861165bfc554f92dc78d2abf5afe5631db3579555d97409  go1.16.4.freebsd-386.tar.gz
-5d9301324148ed4dbfaa0800da43a843ffd65c834ee73fcf087255697c925f74  go1.18.1.linux-s390x.tar.gz
+ccdd2b76de1941b60734408fda0d750aaa69330d8a07430eed4c56bdb3502f6f  go1.16.4.freebsd-amd64.tar.gz
-49ae65551acbfaa57b52fbefa0350b2072512ae3103b8cf1a919a02626dbc743  go1.18.1.windows-386.zip
+80cfac566e344096a8df8f37bbd21f89e76a6fbe601406565d71a87a665fc125  go1.16.4.linux-ppc64le.tar.gz
-c30bc3f1f7314a953fe208bd9cd5e24bd9403392a6c556ced3677f9f70f71fe1  go1.18.1.windows-amd64.zip
+d6431881b3573dc29ecc24fbeab5e5ec25d8c9273aa543769c86a1a3bbac1ddf  go1.16.4.linux-s390x.tar.gz
-2c4a8265030eac37f906634f5c13c22c3d0ea725f2488e1bca005c6b981653d7  go1.18.1.windows-arm64.zip
 
-03c181fc1bb29ea3e73cbb23399c43b081063833a7cf7554b94e5a98308df53e  golangci-lint-1.45.2-linux-riscv64.deb
+7e9a47ab540aa3e8472fbf8120d28bed3b9d9cf625b955818e8bc69628d7187c  golangci-lint-1.39.0-darwin-amd64.tar.gz
-08a50bbbf451ede6d5354179eb3e14a5634e156dfa92cb9a2606f855a637e35b  golangci-lint-1.45.2-linux-ppc64le.rpm
+574daa2c9c299b01672a6daeb1873b5f12e413cdb6dc0e30f2ff163956778064  golangci-lint-1.39.0-darwin-arm64.tar.gz
-0d12f6ec1296b5a70e392aa88cd2295cceef266165eb7028e675f455515dd1c9  golangci-lint-1.45.2-linux-armv7.deb
+6225f7014987324ab78e9b511f294e3f25be013728283c33918c67c8576d543e  golangci-lint-1.39.0-freebsd-386.tar.gz
-10f2846e2e50e4ea8ae426ee62dcd2227b23adddd8e991aa3c065927ac948735  golangci-lint-1.45.2-linux-ppc64le.deb
+6b3e76e1e5eaf0159411c8e2727f8d533989d3bb19f10e9caa6e0b9619ee267d  golangci-lint-1.39.0-freebsd-amd64.tar.gz
-1463049b744871168095e3e8f687247d6040eeb895955b869889ea151e0603ab  golangci-lint-1.45.2-linux-arm64.tar.gz
+a301cacfff87ed9b00313d95278533c25a4527a06b040a17d969b4b7e1b8a90d  golangci-lint-1.39.0-freebsd-armv7.tar.gz
-15720f9c4c6f9324af695f081dc189adc7751b255759e78d7b2df1d7e9192533  golangci-lint-1.45.2-linux-amd64.deb
+25bfd96a29c3112f508d5e4fc860dbad7afce657233c343acfa20715717d51e7  golangci-lint-1.39.0-freebsd-armv6.tar.gz
-166d922e4d3cfe3d47786c590154a9c8ea689dff0aa92b73d2f5fc74fc570c29  golangci-lint-1.45.2-linux-arm64.rpm
+9687e4ff15545cfc722b0e46107a94195166a505023b48a316579af25ad09505  golangci-lint-1.39.0-linux-armv7.tar.gz
-1a3754c69f7cc19ab89cbdcc2550da4cf9abb3120383c6b3bd440c1ec22da2e6  golangci-lint-1.45.2-freebsd-386.tar.gz
+a7fa7ab2bfc99cbe5e5bcbf5684f5a997f920afbbe2f253d2feb1001d5e3c8b3  golangci-lint-1.39.0-linux-armv6.tar.gz
-1dec0aa46d4f0d241863b573f70129bdf1de9c595cf51172a840a588a4cd9fc5  golangci-lint-1.45.2-windows-amd64.zip
+c8f9634115beddb4ed9129c1f7ecd4c97c99d07aeef33e3707234097eeb51b7b  golangci-lint-1.39.0-linux-mips64le.tar.gz
-3198453806517c1ad988229f5e758ef850e671203f46d6905509df5bdf4dc24b  golangci-lint-1.45.2-freebsd-armv7.tar.gz
+d1234c213b74751f1af413302dde0e9a6d4d29aecef034af7abb07dc1b6e887f  golangci-lint-1.39.0-linux-arm64.tar.gz
-46a3cd1749d7b98adc2dc01510ddbe21abe42689c8a53fb0e81662713629f215  golangci-lint-1.45.2-linux-386.deb
+df25d9267168323b163147acb823ab0215a8a3bb6898a4a9320afdfedde66817  golangci-lint-1.39.0-linux-386.tar.gz
-4e28bfb593d464b9e160f2acd5b71993836a183270bf8299b78ad31f7a168c0d  golangci-lint-1.45.2-linux-arm64.deb
+1767e75fba357b7651b1a796d38453558f371c60af805505ec99e166908c04b5  golangci-lint-1.39.0-linux-ppc64le.tar.gz
-5157a58c8f9ab85c33af2e46f0d7c57a3b1e8953b81d61130e292e09f545cfab  golangci-lint-1.45.2-linux-mips64le.tar.gz
+25fd75bf3186b3d930ecae10185689968fd18fd8fa6f9f555d6beb04348c20f6  golangci-lint-1.39.0-linux-s390x.tar.gz
-518cd027644129fbf8ec4f02bd6f9ad7278aae826f92b63c80d4d0819ddde49a  golangci-lint-1.45.2-linux-armv6.rpm
+3a73aa7468087caa62673c8adea99b4e4dff846dc72707222db85f8679b40cbf  golangci-lint-1.39.0-linux-amd64.tar.gz
-595ad6c6dade4c064351bc309f411703e457f8ffbb7a1806b3d8ee713333427f  golangci-lint-1.45.2-linux-amd64.tar.gz
+578caceccf81739bda67dbfec52816709d03608c6878888ecdc0e186a094a41b  golangci-lint-1.39.0-linux-mips64.tar.gz
-6994d6c80f0730751090986184a3481b4be2e6b6e84416238a2b857910045a4f  golangci-lint-1.45.2-windows-arm64.zip
+494b66ba0e32c8ddf6c4f6b1d05729b110900f6017eda943057e43598c17d7a8  golangci-lint-1.39.0-windows-386.zip
-6c81652fc340118811b487f713c441fc6f527800bf5fd11b8929d08124efa015  golangci-lint-1.45.2-linux-armv7.tar.gz
+52ec2e13a3cbb47147244dff8cfc35103563deb76e0459133058086fc35fb2c7  golangci-lint-1.39.0-windows-amd64.zip
-726cb045559b7518bafdd3459de70a0647c087eb1b4634627a4b2e95b1258580  golangci-lint-1.45.2-freebsd-amd64.tar.gz
-77df3774cdfda49b956d4a0e676da9a9b883f496ee37293c530770fef6b1d24e  golangci-lint-1.45.2-linux-mips64.deb
-7a9840f279a7d5d405bb434e101c2290964b3729630ac2add29280b962b7b9a5  golangci-lint-1.45.2-windows-armv6.zip
-7d4bf9a5d80ec467aaaf66e78dbdcab567bbc6ba8151334c714eee58766aae32  golangci-lint-1.45.2-windows-armv7.zip
-7e5f8821d39bb11d273b0841b34355f56bd5a45a2d5179f0d09e614e0efc0482  golangci-lint-1.45.2-linux-s390x.rpm
-828de1bde796b23d8656b17a8885fbd879ef612795d62d1e4618126b419728b5  golangci-lint-1.45.2-linux-mips64.rpm
-879a52107a797678a03c175cc7cf441411a14a01f66dc87f70bdfa304a4129a6  golangci-lint-1.45.2-windows-386.zip
-87b6c7e3a3769f7d9abeb3bb82119b3c91e3c975300f6834fdeef8b2e37c98ff  golangci-lint-1.45.2-linux-amd64.rpm
-8b605c6d686c8af53ecc4ef39544541eeb1644d34cc10f9ffc5087808210c4ff  golangci-lint-1.45.2-linux-s390x.deb
-9427dbf51d0ac6f73a0f992838bd40c817470cc5bf6c8e2e2bea6fac46d7af6e  golangci-lint-1.45.2-linux-ppc64le.tar.gz
-995e509e895ca6a64ffc7395ac884d5961bdec98423cb896b17f345a9b4a19cf  golangci-lint-1.45.2-darwin-amd64.tar.gz
-a3f36278f2ea5516341e9071a2df6e65df272be80230b5406a12b72c6d425bee  golangci-lint-1.45.2-linux-armv7.rpm
-a5e12c50c23e87ac1deffc872f92ae85427b1198604969399805ae47cfe43f08  golangci-lint-1.45.2-linux-riscv64.tar.gz
-aa8fa1be0729dbc2fbc4e01e82027097613eee74bd686ebef20f860b01fff8b3  golangci-lint-1.45.2-freebsd-armv6.tar.gz
-c2b9669decc1b638cf2ee9060571af4e255f6dfcbb225c293e3a7ee4bb2c7217  golangci-lint-1.45.2-darwin-arm64.tar.gz
-dfa8bdaf0387aec1cd5c1aa8857f67b2bbdfc2e42efce540c8fb9bbe3e8af302  golangci-lint-1.45.2-linux-armv6.tar.gz
-eb8b8539dd017eee5c131ea9b875893ab2cebeeca41e8c6624907fb02224d643  golangci-lint-1.45.2-linux-386.rpm
-ed6c7e17a857f30d715c5302fa250d95936936b277024bffea201187a257d7a7  golangci-lint-1.45.2-linux-armv6.deb
-ef4d0154ace4001f01b288baeb118176242efb4fd163e178763e3213b77ef30b  golangci-lint-1.45.2-linux-mips64le.deb
-ef7002a2229f5ff5ba201a715fcf877664ea88decbe58e69d163293913024955  golangci-lint-1.45.2-linux-s390x.tar.gz
-f13ecbd09228632e6bbe91a8324bd675c406eed22eb6d2c1e8192eed9ec4f914  golangci-lint-1.45.2-linux-386.tar.gz
-f4cd9cfb09252f51699407277512263cae8409b665dd764f55a34738d0e89edc  golangci-lint-1.45.2-linux-riscv64.rpm
-fb1945dc59d37c9d14bf0a4aea11ea8651fa0e1d582ea80c4c44d0a536c08893  golangci-lint-1.45.2-linux-mips64.tar.gz
-fe542c22738010f453c735a3c410decfd3784d1bd394b395c298ee298fc4c606  golangci-lint-1.45.2-linux-mips64le.rpm

build/ci.go

@@ -14,7 +14,6 @@
 // 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/>.
 
-//go:build none
 // +build none
 
 /*
@@ -33,6 +32,7 @@ Available commands are:
    nsis                                                                                        -- creates a Windows NSIS installer
    aar        [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ]                      -- creates an Android archive
    xcode      [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ]                      -- creates an iOS XCode framework
+   xgo        [ -alltools ] [ options ]                                                        -- cross builds according to options
    purge      [ -store blobstore ] [ -days threshold ]                                         -- purges old archives from the blobstore
 
 For all commands, -n prevents execution of external programs (dry run mode).
@@ -129,15 +129,20 @@ var (
 
 	// Distros for which packages are created.
 	// Note: vivid is unsupported because there is no golang-1.6 package for it.
-	// Note: the following Ubuntu releases have been officially deprecated on Launchpad:
+	// Note: wily is unsupported because it was officially deprecated on Launchpad.
-	//   wily, yakkety, zesty, artful, cosmic, disco, eoan, groovy, hirsuite
+	// 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", // EOL: 04/2024
+		"trusty":  "golang-1.11",
-		"xenial": "golang-go",   // EOL: 04/2026
+		"xenial":  "golang-go",
-		"bionic": "golang-go",   // EOL: 04/2028
+		"bionic":  "golang-go",
-		"focal":  "golang-go",   // EOL: 04/2030
+		"focal":   "golang-go",
-		"impish": "golang-go",   // EOL: 07/2022
+		"groovy":  "golang-go",
-		// "jammy": "golang-go",   // EOL: 04/2027
+		"hirsute": "golang-go",
 	}
 
 	debGoBootPaths = map[string]string{
@@ -148,7 +153,7 @@ var (
 	// This is the version of go that will be downloaded by
 	//
 	//     go run ci.go install -dlgo
-	dlgoVersion = "1.18.1"
+	dlgoVersion = "1.16.4"
 )
 
 var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin"))
@@ -188,6 +193,8 @@ func main() {
 		doAndroidArchive(os.Args[2:])
 	case "xcode":
 		doXCodeFramework(os.Args[2:])
+	case "xgo":
+		doXgo(os.Args[2:])
 	case "purge":
 		doPurge(os.Args[2:])
 	default:
@@ -258,11 +265,6 @@ func buildFlags(env build.Environment) (flags []string) {
 	if runtime.GOOS == "darwin" {
 		ld = append(ld, "-s")
 	}
-	// Enforce the stacksize to 8M, which is the case on most platforms apart from
-	// alpine Linux.
-	if runtime.GOOS == "linux" {
-		ld = append(ld, "-extldflags", "-Wl,-z,stack-size=0x800000")
-	}
 	if len(ld) > 0 {
 		flags = append(flags, "-ldflags", strings.Join(ld, " "))
 	}
@@ -280,7 +282,6 @@ func doTest(cmdline []string) {
 		cc       = flag.String("cc", "", "Sets C compiler binary")
 		coverage = flag.Bool("coverage", false, "Whether to record code coverage")
 		verbose  = flag.Bool("v", false, "Whether to log verbosely")
-		race     = flag.Bool("race", false, "Execute the race detector")
 	)
 	flag.CommandLine.Parse(cmdline)
 
@@ -301,9 +302,6 @@ func doTest(cmdline []string) {
 	if *verbose {
 		gotest.Args = append(gotest.Args, "-v")
 	}
-	if *race {
-		gotest.Args = append(gotest.Args, "-race")
-	}
 
 	packages := []string{"./..."}
 	if len(flag.CommandLine.Args()) > 0 {
@@ -332,21 +330,12 @@ func doLint(cmdline []string) {
 
 // downloadLinter downloads and unpacks golangci-lint.
 func downloadLinter(cachedir string) string {
-	const version = "1.45.2"
+	const version = "1.39.0"
 
 	csdb := build.MustLoadChecksums("build/checksums.txt")
-	arch := runtime.GOARCH
+	base := fmt.Sprintf("golangci-lint-%s-%s-%s", version, runtime.GOOS, runtime.GOARCH)
-	ext := ".tar.gz"
+	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 runtime.GOOS == "windows" {
-		ext = ".zip"
-	}
-	if arch == "arm" {
-		arch += "v" + os.Getenv("GOARM")
-	}
-	base := fmt.Sprintf("golangci-lint-%s-%s-%s", version, runtime.GOOS, arch)
-	url := fmt.Sprintf("https://github.com/golangci/golangci-lint/releases/download/v%s/%s%s", version, base, ext)
-	archivePath := filepath.Join(cachedir, base+ext)
 	if err := csdb.DownloadFile(url, archivePath); err != nil {
 		log.Fatal(err)
 	}
@@ -1133,7 +1122,11 @@ func doXCodeFramework(cmdline []string) {
 	tc := new(build.GoToolchain)
 
 	// Build gomobile.
-	build.MustRun(tc.Install(GOBIN, "golang.org/x/mobile/cmd/gomobile", "golang.org/x/mobile/cmd/gobind"))
+	build.MustRun(tc.Install(GOBIN, "golang.org/x/mobile/cmd/gomobile@latest", "golang.org/x/mobile/cmd/gobind@latest"))
+
+	// Ensure all dependencies are available. This is required to make
+	// gomobile bind work because it expects go.sum to contain all checksums.
+	build.MustRun(tc.Go("mod", "download"))
 
 	// Build the iOS XCode framework
 	bind := gomobileTool("bind", "-ldflags", "-s -w", "--target", "ios", "-v", "github.com/ethereum/go-ethereum/mobile")
@@ -1212,6 +1205,48 @@ func newPodMetadata(env build.Environment, archive string) podMetadata {
 	}
 }
 
+// Cross compilation
+
+func doXgo(cmdline []string) {
+	var (
+		alltools = flag.Bool("alltools", false, `Flag whether we're building all known tools, or only on in particular`)
+	)
+	flag.CommandLine.Parse(cmdline)
+	env := build.Env()
+	var tc build.GoToolchain
+
+	// Make sure xgo is available for cross compilation
+	build.MustRun(tc.Install(GOBIN, "github.com/karalabe/xgo@latest"))
+
+	// If all tools building is requested, build everything the builder wants
+	args := append(buildFlags(env), flag.Args()...)
+
+	if *alltools {
+		args = append(args, []string{"--dest", GOBIN}...)
+		for _, res := range allToolsArchiveFiles {
+			if strings.HasPrefix(res, GOBIN) {
+				// Binary tool found, cross build it explicitly
+				args = append(args, "./"+filepath.Join("cmd", filepath.Base(res)))
+				build.MustRun(xgoTool(args))
+				args = args[:len(args)-1]
+			}
+		}
+		return
+	}
+
+	// Otherwise execute the explicit cross compilation
+	path := args[len(args)-1]
+	args = append(args[:len(args)-1], []string{"--dest", GOBIN, path}...)
+	build.MustRun(xgoTool(args))
+}
+
+func xgoTool(args []string) *exec.Cmd {
+	cmd := exec.Command(filepath.Join(GOBIN, "xgo"), args...)
+	cmd.Env = os.Environ()
+	cmd.Env = append(cmd.Env, []string{"GOBIN=" + GOBIN}...)
+	return cmd
+}
+
 // Binary distribution cleanups
 
 func doPurge(cmdline []string) {
@@ -1239,21 +1274,21 @@ func doPurge(cmdline []string) {
 
 	// Iterate over the blobs, collect and sort all unstable builds
 	for i := 0; i < len(blobs); i++ {
-		if !strings.Contains(*blobs[i].Name, "unstable") {
+		if !strings.Contains(blobs[i].Name, "unstable") {
 			blobs = append(blobs[:i], blobs[i+1:]...)
 			i--
 		}
 	}
 	for i := 0; i < len(blobs); i++ {
 		for j := i + 1; j < len(blobs); j++ {
-			if blobs[i].Properties.LastModified.After(*blobs[j].Properties.LastModified) {
+			if blobs[i].Properties.LastModified.After(blobs[j].Properties.LastModified) {
 				blobs[i], blobs[j] = blobs[j], blobs[i]
 			}
 		}
 	}
 	// Filter out all archives more recent that the given threshold
 	for i, blob := range blobs {
-		if time.Since(*blob.Properties.LastModified) < time.Duration(*limit)*24*time.Hour {
+		if time.Since(blob.Properties.LastModified) < time.Duration(*limit)*24*time.Hour {
 			blobs = blobs[:i]
 			break
 		}

build/deb/ethereum/deb.control

@@ -5,7 +5,7 @@ Maintainer: {{.Author}}
 Build-Depends: debhelper (>= 8.0.0), {{.GoBootPackage}}
 Standards-Version: 3.9.5
 Homepage: https://ethereum.org
-Vcs-Git: https://github.com/ethereum/go-ethereum.git
+Vcs-Git: git://github.com/ethereum/go-ethereum.git
 Vcs-Browser: https://github.com/ethereum/go-ethereum
 
 Package: {{.Name}}

build/tools/tools.go

@@ -1,32 +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/>.
-
-//go:build tools
-// +build tools
-
-package tools
-
-import (
-	// Tool imports for go:generate.
-	_ "github.com/fjl/gencodec"
-	_ "github.com/golang/protobuf/protoc-gen-go"
-	_ "github.com/kevinburke/go-bindata/go-bindata"
-	_ "golang.org/x/tools/cmd/stringer"
-
-	// Tool imports for mobile build.
-	_ "golang.org/x/mobile/cmd/gobind"
-	_ "golang.org/x/mobile/cmd/gomobile"
-)

cmd/clef/main.go

@@ -661,7 +661,7 @@ func signer(c *cli.Context) error {
 		if err != nil {
 			utils.Fatalf("Could not register API: %w", err)
 		}
-		handler := node.NewHTTPHandlerStack(srv, cors, vhosts, nil)
+		handler := node.NewHTTPHandlerStack(srv, cors, vhosts)
 
 		// set port
 		port := c.Int(rpcPortFlag.Name)
@@ -898,7 +898,7 @@ func testExternalUI(api *core.SignerAPI) {
 		addr, _ := common.NewMixedcaseAddressFromString("0x0011223344556677889900112233445566778899")
 		data := `{"types":{"EIP712Domain":[{"name":"name","type":"string"},{"name":"version","type":"string"},{"name":"chainId","type":"uint256"},{"name":"verifyingContract","type":"address"}],"Person":[{"name":"name","type":"string"},{"name":"test","type":"uint8"},{"name":"wallet","type":"address"}],"Mail":[{"name":"from","type":"Person"},{"name":"to","type":"Person"},{"name":"contents","type":"string"}]},"primaryType":"Mail","domain":{"name":"Ether Mail","version":"1","chainId":"1","verifyingContract":"0xCCCcccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC"},"message":{"from":{"name":"Cow","test":"3","wallet":"0xcD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826"},"to":{"name":"Bob","wallet":"0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB","test":"2"},"contents":"Hello, Bob!"}}`
 		//_, err := api.SignData(ctx, accounts.MimetypeTypedData, *addr, hexutil.Encode([]byte(data)))
-		var typedData apitypes.TypedData
+		var typedData core.TypedData
 		json.Unmarshal([]byte(data), &typedData)
 		_, err := api.SignTypedData(ctx, *addr, typedData)
 		expectApprove("sign 712 typed data", err)
@@ -1025,7 +1025,7 @@ func GenDoc(ctx *cli.Context) {
 			"of the work in canonicalizing and making sense of the data, and it's up to the UI to present" +
 			"the user with the contents of the `message`"
 		sighash, msg := accounts.TextAndHash([]byte("hello world"))
-		messages := []*apitypes.NameValueType{{Name: "message", Value: msg, Typ: accounts.MimetypeTextPlain}}
+		messages := []*core.NameValueType{{Name: "message", Value: msg, Typ: accounts.MimetypeTextPlain}}
 
 		add("SignDataRequest", desc, &core.SignDataRequest{
 			Address:     common.NewMixedcaseAddress(a),

cmd/devp2p/dns_cloudflare.go

@@ -133,8 +133,7 @@ func (c *cloudflareClient) uploadRecords(name string, records map[string]string)
 			log.Info(fmt.Sprintf("Creating %s = %q", path, val))
 			ttl := rootTTL
 			if path != name {
-				ttl = treeNodeTTLCloudflare // Max TTL permitted by Cloudflare
+				ttl = treeNodeTTL // Max TTL permitted by Cloudflare
-
 			}
 			record := cloudflare.DNSRecord{Type: "TXT", Name: path, Content: val, TTL: ttl}
 			_, err = c.CreateDNSRecord(context.Background(), c.zoneID, record)

cmd/devp2p/dnscmd.go

@@ -115,9 +115,8 @@ var (
 )
 
 const (
-	rootTTL               = 30 * 60              // 30 min
+	rootTTL     = 30 * 60              // 30 min
-	treeNodeTTL           = 4 * 7 * 24 * 60 * 60 // 4 weeks
+	treeNodeTTL = 4 * 7 * 24 * 60 * 60 // 4 weeks
-	treeNodeTTLCloudflare = 24 * 60 * 60         // 1 day
 )
 
 // dnsSync performs dnsSyncCommand.

cmd/devp2p/internal/ethtest/chain.go

@@ -26,7 +26,6 @@ import (
 	"os"
 	"strings"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/forkid"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -40,6 +39,16 @@ type Chain struct {
 	chainConfig *params.ChainConfig
 }
 
+func (c *Chain) WriteTo(writer io.Writer) error {
+	for _, block := range c.blocks {
+		if err := rlp.Encode(writer, block); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 // Len returns the length of the chain.
 func (c *Chain) Len() int {
 	return len(c.blocks)
@@ -68,13 +77,6 @@ func (c *Chain) TotalDifficultyAt(height int) *big.Int {
 	return sum
 }
 
-func (c *Chain) RootAt(height int) common.Hash {
-	if height < c.Len() {
-		return c.blocks[height].Root()
-	}
-	return common.Hash{}
-}
-
 // ForkID gets the fork id of the chain.
 func (c *Chain) ForkID() forkid.ID {
 	return forkid.NewID(c.chainConfig, c.blocks[0].Hash(), uint64(c.Len()))

cmd/devp2p/internal/ethtest/helpers.go

@@ -96,19 +96,6 @@ func (s *Suite) dial66() (*Conn, error) {
 	return conn, nil
 }
 
-// dial66 attempts to dial the given node and perform a handshake,
-// returning the created Conn with additional snap/1 capabilities if
-// successful.
-func (s *Suite) dialSnap() (*Conn, error) {
-	conn, err := s.dial66()
-	if err != nil {
-		return nil, fmt.Errorf("dial failed: %v", err)
-	}
-	conn.caps = append(conn.caps, p2p.Cap{Name: "snap", Version: 1})
-	conn.ourHighestSnapProtoVersion = 1
-	return conn, nil
-}
-
 // peer performs both the protocol handshake and the status message
 // exchange with the node in order to peer with it.
 func (c *Conn) peer(chain *Chain, status *Status) error {
@@ -144,11 +131,7 @@ func (c *Conn) handshake() error {
 		}
 		c.negotiateEthProtocol(msg.Caps)
 		if c.negotiatedProtoVersion == 0 {
-			return fmt.Errorf("could not negotiate eth protocol (remote caps: %v, local eth version: %v)", msg.Caps, c.ourHighestProtoVersion)
+			return fmt.Errorf("unexpected eth protocol version")
-		}
-		// If we require snap, verify that it was negotiated
-		if c.ourHighestSnapProtoVersion != c.negotiatedSnapProtoVersion {
-			return fmt.Errorf("could not negotiate snap protocol (remote caps: %v, local snap version: %v)", msg.Caps, c.ourHighestSnapProtoVersion)
 		}
 		return nil
 	default:
@@ -160,21 +143,15 @@ func (c *Conn) handshake() error {
 // advertised capability from peer.
 func (c *Conn) negotiateEthProtocol(caps []p2p.Cap) {
 	var highestEthVersion uint
-	var highestSnapVersion uint
 	for _, capability := range caps {
-		switch capability.Name {
+		if capability.Name != "eth" {
-		case "eth":
+			continue
-			if capability.Version > highestEthVersion && capability.Version <= c.ourHighestProtoVersion {
+		}
-				highestEthVersion = capability.Version
+		if capability.Version > highestEthVersion && capability.Version <= c.ourHighestProtoVersion {
-			}
+			highestEthVersion = capability.Version
-		case "snap":
-			if capability.Version > highestSnapVersion && capability.Version <= c.ourHighestSnapProtoVersion {
-				highestSnapVersion = capability.Version
-			}
 		}
 	}
 	c.negotiatedProtoVersion = highestEthVersion
-	c.negotiatedSnapProtoVersion = highestSnapVersion
 }
 
 // statusExchange performs a `Status` message exchange with the given node.
@@ -265,17 +242,9 @@ func (s *Suite) createSendAndRecvConns(isEth66 bool) (*Conn, *Conn, error) {
 	return sendConn, recvConn, nil
 }
 
-func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
-	if c.negotiatedProtoVersion == 66 {
-		_, msg := c.readAndServe66(chain, timeout)
-		return msg
-	}
-	return c.readAndServe65(chain, timeout)
-}
-
 // readAndServe serves GetBlockHeaders requests while waiting
 // on another message from the node.
-func (c *Conn) readAndServe65(chain *Chain, timeout time.Duration) Message {
+func (c *Conn) readAndServe(chain *Chain, timeout time.Duration) Message {
 	start := time.Now()
 	for time.Since(start) < timeout {
 		c.SetReadDeadline(time.Now().Add(5 * time.Second))
@@ -310,8 +279,8 @@ func (c *Conn) readAndServe66(chain *Chain, timeout time.Duration) (uint64, Mess
 		switch msg := msg.(type) {
 		case *Ping:
 			c.Write(&Pong{})
-		case GetBlockHeaders:
+		case *GetBlockHeaders:
-			headers, err := chain.GetHeaders(msg)
+			headers, err := chain.GetHeaders(*msg)
 			if err != nil {
 				return 0, errorf("could not get headers for inbound header request: %v", err)
 			}
@@ -348,15 +317,6 @@ func (c *Conn) headersRequest(request *GetBlockHeaders, chain *Chain, isEth66 bo
 	}
 }
 
-func (c *Conn) snapRequest(msg Message, id uint64, chain *Chain) (Message, error) {
-	defer c.SetReadDeadline(time.Time{})
-	c.SetReadDeadline(time.Now().Add(5 * time.Second))
-	if err := c.Write(msg); err != nil {
-		return nil, fmt.Errorf("could not write to connection: %v", err)
-	}
-	return c.ReadSnap(id)
-}
-
 // getBlockHeaders66 executes the given `GetBlockHeaders` request over the eth66 protocol.
 func getBlockHeaders66(chain *Chain, conn *Conn, request *GetBlockHeaders, id uint64) (BlockHeaders, error) {
 	// write request

cmd/devp2p/internal/ethtest/snap.go

@@ -1,675 +0,0 @@
-// Copyright 2014 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package ethtest
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"math/rand"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/protocols/snap"
-	"github.com/ethereum/go-ethereum/internal/utesting"
-	"github.com/ethereum/go-ethereum/light"
-	"github.com/ethereum/go-ethereum/trie"
-	"golang.org/x/crypto/sha3"
-)
-
-func (s *Suite) TestSnapStatus(t *utesting.T) {
-	conn, err := s.dialSnap()
-	if err != nil {
-		t.Fatalf("dial failed: %v", err)
-	}
-	defer conn.Close()
-	if err := conn.peer(s.chain, nil); err != nil {
-		t.Fatalf("peering failed: %v", err)
-	}
-}
-
-type accRangeTest struct {
-	nBytes uint64
-	root   common.Hash
-	origin common.Hash
-	limit  common.Hash
-
-	expAccounts int
-	expFirst    common.Hash
-	expLast     common.Hash
-}
-
-// TestSnapGetAccountRange various forms of GetAccountRange requests.
-func (s *Suite) TestSnapGetAccountRange(t *utesting.T) {
-	var (
-		root           = s.chain.RootAt(999)
-		ffHash         = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
-		zero           = common.Hash{}
-		firstKeyMinus1 = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf29")
-		firstKey       = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
-		firstKeyPlus1  = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2b")
-		secondKey      = common.HexToHash("0x09e47cd5056a689e708f22fe1f932709a320518e444f5f7d8d46a3da523d6606")
-		storageRoot    = common.HexToHash("0xbe3d75a1729be157e79c3b77f00206db4d54e3ea14375a015451c88ec067c790")
-	)
-	for i, tc := range []accRangeTest{
-		// Tests decreasing the number of bytes
-		{4000, root, zero, ffHash, 76, firstKey, common.HexToHash("0xd2669dcf3858e7f1eecb8b5fedbf22fbea3e9433848a75035f79d68422c2dcda")},
-		{3000, root, zero, ffHash, 57, firstKey, common.HexToHash("0x9b63fa753ece5cb90657d02ecb15df4dc1508d8c1d187af1bf7f1a05e747d3c7")},
-		{2000, root, zero, ffHash, 38, firstKey, common.HexToHash("0x5e6140ecae4354a9e8f47559a8c6209c1e0e69cb077b067b528556c11698b91f")},
-		{1, root, zero, ffHash, 1, firstKey, firstKey},
-
-		// Tests variations of the range
-		//
-		// [00b to firstkey]: should return [firstkey, secondkey], where secondkey is out of bounds
-		{4000, root, common.HexToHash("0x00bf000000000000000000000000000000000000000000000000000000000000"), common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2b"), 2, firstKey, secondKey},
-		// [00b0 to 0bf0]: where both are before firstkey. Should return firstKey (even though it's out of bounds)
-		{4000, root, common.HexToHash("0x00b0000000000000000000000000000000000000000000000000000000000000"), common.HexToHash("0x00bf100000000000000000000000000000000000000000000000000000000000"), 1, firstKey, firstKey},
-		{4000, root, zero, zero, 1, firstKey, firstKey},
-		{4000, root, firstKey, ffHash, 76, firstKey, common.HexToHash("0xd2669dcf3858e7f1eecb8b5fedbf22fbea3e9433848a75035f79d68422c2dcda")},
-		{4000, root, firstKeyPlus1, ffHash, 76, secondKey, common.HexToHash("0xd28f55d3b994f16389f36944ad685b48e0fc3f8fbe86c3ca92ebecadf16a783f")},
-
-		// Test different root hashes
-		//
-		// A stateroot that does not exist
-		{4000, common.Hash{0x13, 37}, zero, ffHash, 0, zero, zero},
-		// The genesis stateroot (we expect it to not be served)
-		{4000, s.chain.RootAt(0), zero, ffHash, 0, zero, zero},
-		// A 127 block old stateroot, expected to be served
-		{4000, s.chain.RootAt(999 - 127), zero, ffHash, 77, firstKey, common.HexToHash("0xe4c6fdef5dd4e789a2612390806ee840b8ec0fe52548f8b4efe41abb20c37aac")},
-		// A root which is not actually an account root, but a storage orot
-		{4000, storageRoot, zero, ffHash, 0, zero, zero},
-
-		// And some non-sensical requests
-		//
-		// range from [0xFF to 0x00], wrong order. Expect not to be serviced
-		{4000, root, ffHash, zero, 0, zero, zero},
-		// range from [firstkey, firstkey-1], wrong order. Expect to get first key.
-		{4000, root, firstKey, firstKeyMinus1, 1, firstKey, firstKey},
-		// range from [firstkey, 0], wrong order. Expect to get first key.
-		{4000, root, firstKey, zero, 1, firstKey, firstKey},
-		// Max bytes: 0. Expect to deliver one account.
-		{0, root, zero, ffHash, 1, firstKey, firstKey},
-	} {
-		if err := s.snapGetAccountRange(t, &tc); err != nil {
-			t.Errorf("test %d \n root: %x\n range: %#x - %#x\n bytes: %d\nfailed: %v", i, tc.root, tc.origin, tc.limit, tc.nBytes, err)
-		}
-	}
-}
-
-type stRangesTest struct {
-	root     common.Hash
-	accounts []common.Hash
-	origin   []byte
-	limit    []byte
-	nBytes   uint64
-
-	expSlots int
-}
-
-// TestSnapGetStorageRange various forms of GetStorageRanges requests.
-func (s *Suite) TestSnapGetStorageRanges(t *utesting.T) {
-	var (
-		ffHash    = common.HexToHash("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
-		zero      = common.Hash{}
-		firstKey  = common.HexToHash("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
-		secondKey = common.HexToHash("0x09e47cd5056a689e708f22fe1f932709a320518e444f5f7d8d46a3da523d6606")
-	)
-	for i, tc := range []stRangesTest{
-		{
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{secondKey, firstKey},
-			origin:   zero[:],
-			limit:    ffHash[:],
-			nBytes:   500,
-			expSlots: 0,
-		},
-
-		/*
-			Some tests against this account:
-			{
-			  "balance": "0",
-			  "nonce": 1,
-			  "root": "0xbe3d75a1729be157e79c3b77f00206db4d54e3ea14375a015451c88ec067c790",
-			  "codeHash": "0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
-			  "storage": {
-			    "0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace": "02",
-			    "0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6": "01",
-			    "0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b": "03"
-			  },
-			  "key": "0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844"
-			}
-		*/
-		{ // [:] -> [slot1, slot2, slot3]
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{common.HexToHash("0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844")},
-			origin:   zero[:],
-			limit:    ffHash[:],
-			nBytes:   500,
-			expSlots: 3,
-		},
-		{ // [slot1:] -> [slot1, slot2, slot3]
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{common.HexToHash("0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844")},
-			origin:   common.FromHex("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
-			limit:    ffHash[:],
-			nBytes:   500,
-			expSlots: 3,
-		},
-		{ // [slot1+ :] -> [slot2, slot3]
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{common.HexToHash("0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844")},
-			origin:   common.FromHex("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5acf"),
-			limit:    ffHash[:],
-			nBytes:   500,
-			expSlots: 2,
-		},
-		{ // [slot1:slot2] -> [slot1, slot2]
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{common.HexToHash("0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844")},
-			origin:   common.FromHex("0x405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace"),
-			limit:    common.FromHex("0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6"),
-			nBytes:   500,
-			expSlots: 2,
-		},
-		{ // [slot1+:slot2+] -> [slot2, slot3]
-			root:     s.chain.RootAt(999),
-			accounts: []common.Hash{common.HexToHash("0xf493f79c43bd747129a226ad42529885a4b108aba6046b2d12071695a6627844")},
-			origin:   common.FromHex("0x4fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
-			limit:    common.FromHex("0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf7"),
-			nBytes:   500,
-			expSlots: 2,
-		},
-	} {
-		if err := s.snapGetStorageRanges(t, &tc); err != nil {
-			t.Errorf("test %d \n root: %x\n range: %#x - %#x\n bytes: %d\n #accounts: %d\nfailed: %v",
-				i, tc.root, tc.origin, tc.limit, tc.nBytes, len(tc.accounts), err)
-		}
-	}
-}
-
-type byteCodesTest struct {
-	nBytes uint64
-	hashes []common.Hash
-
-	expHashes int
-}
-
-var (
-	// emptyRoot is the known root hash of an empty trie.
-	emptyRoot = common.HexToHash("56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
-	// emptyCode is the known hash of the empty EVM bytecode.
-	emptyCode = common.HexToHash("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")
-)
-
-// TestSnapGetByteCodes various forms of GetByteCodes requests.
-func (s *Suite) TestSnapGetByteCodes(t *utesting.T) {
-	// The halfchain import should yield these bytecodes
-	var hcBytecodes []common.Hash
-	for _, s := range []string{
-		"0x200c90460d8b0063210d5f5b9918e053c8f2c024485e0f1b48be8b1fc71b1317",
-		"0x20ba67ed4ac6aff626e0d1d4db623e2fada9593daeefc4a6eb4b70e6cff986f3",
-		"0x24b5b4902cb3d897c1cee9f16be8e897d8fa277c04c6dc8214f18295fca5de44",
-		"0x320b9d0a2be39b8a1c858f9f8cb96b1df0983071681de07ded3a7c0d05db5fd6",
-		"0x48cb0d5275936a24632babc7408339f9f7b051274809de565b8b0db76e97e03c",
-		"0x67c7a6f5cdaa43b4baa0e15b2be63346d1b9ce9f2c3d7e5804e0cacd44ee3b04",
-		"0x6d8418059bdc8c3fabf445e6bfc662af3b6a4ae45999b953996e42c7ead2ab49",
-		"0x7043422e5795d03f17ee0463a37235258e609fdd542247754895d72695e3e142",
-		"0x727f9e6f0c4bac1ff8d72c2972122d9c8d37ccb37e04edde2339e8da193546f1",
-		"0x86ccd5e23c78568a8334e0cebaf3e9f48c998307b0bfb1c378cee83b4bfb29cb",
-		"0x8fc89b00d6deafd4c4279531e743365626dbfa28845ec697919d305c2674302d",
-		"0x92cfc353bcb9746bb6f9996b6b9df779c88af2e9e0eeac44879ca19887c9b732",
-		"0x941b4872104f0995a4898fcf0f615ea6bf46bfbdfcf63ea8f2fd45b3f3286b77",
-		"0xa02fe8f41159bb39d2b704c633c3d6389cf4bfcb61a2539a9155f60786cf815f",
-		"0xa4b94e0afdffcb0af599677709dac067d3145489ea7aede57672bee43e3b7373",
-		"0xaf4e64edd3234c1205b725e42963becd1085f013590bd7ed93f8d711c5eb65fb",
-		"0xb69a18fa855b742031420081999086f6fb56c3930ae8840944e8b8ae9931c51e",
-		"0xc246c217bc73ce6666c93a93a94faa5250564f50a3fdc27ea74c231c07fe2ca6",
-		"0xcd6e4ab2c3034df2a8a1dfaaeb1c4baecd162a93d22de35e854ee2945cbe0c35",
-		"0xe24b692d09d6fc2f3d1a6028c400a27c37d7cbb11511907c013946d6ce263d3b",
-		"0xe440c5f0e8603fd1ed25976eee261ccee8038cf79d6a4c0eb31b2bf883be737f",
-		"0xe6eacbc509203d21ac814b350e72934fde686b7f673c19be8cf956b0c70078ce",
-		"0xe8530de4371467b5be7ea0e69e675ab36832c426d6c1ce9513817c0f0ae1486b",
-		"0xe85d487abbbc83bf3423cf9731360cf4f5a37220e18e5add54e72ee20861196a",
-		"0xf195ea389a5eea28db0be93660014275b158963dec44af1dfa7d4743019a9a49",
-	} {
-		hcBytecodes = append(hcBytecodes, common.HexToHash(s))
-	}
-
-	for i, tc := range []byteCodesTest{
-		// A few stateroots
-		{
-			nBytes: 10000, hashes: []common.Hash{s.chain.RootAt(0), s.chain.RootAt(999)},
-			expHashes: 0,
-		},
-		{
-			nBytes: 10000, hashes: []common.Hash{s.chain.RootAt(0), s.chain.RootAt(0)},
-			expHashes: 0,
-		},
-		// Empties
-		{
-			nBytes: 10000, hashes: []common.Hash{emptyRoot},
-			expHashes: 0,
-		},
-		{
-			nBytes: 10000, hashes: []common.Hash{emptyCode},
-			expHashes: 1,
-		},
-		{
-			nBytes: 10000, hashes: []common.Hash{emptyCode, emptyCode, emptyCode},
-			expHashes: 3,
-		},
-		// The existing bytecodes
-		{
-			nBytes: 10000, hashes: hcBytecodes,
-			expHashes: len(hcBytecodes),
-		},
-		// The existing, with limited byte arg
-		{
-			nBytes: 1, hashes: hcBytecodes,
-			expHashes: 1,
-		},
-		{
-			nBytes: 0, hashes: hcBytecodes,
-			expHashes: 1,
-		},
-		{
-			nBytes: 1000, hashes: []common.Hash{hcBytecodes[0], hcBytecodes[0], hcBytecodes[0], hcBytecodes[0]},
-			expHashes: 4,
-		},
-	} {
-		if err := s.snapGetByteCodes(t, &tc); err != nil {
-			t.Errorf("test %d \n bytes: %d\n #hashes: %d\nfailed: %v", i, tc.nBytes, len(tc.hashes), err)
-		}
-	}
-}
-
-type trieNodesTest struct {
-	root   common.Hash
-	paths  []snap.TrieNodePathSet
-	nBytes uint64
-
-	expHashes []common.Hash
-	expReject bool
-}
-
-func decodeNibbles(nibbles []byte, bytes []byte) {
-	for bi, ni := 0, 0; ni < len(nibbles); bi, ni = bi+1, ni+2 {
-		bytes[bi] = nibbles[ni]<<4 | nibbles[ni+1]
-	}
-}
-
-// hasTerm returns whether a hex key has the terminator flag.
-func hasTerm(s []byte) bool {
-	return len(s) > 0 && s[len(s)-1] == 16
-}
-
-func keybytesToHex(str []byte) []byte {
-	l := len(str)*2 + 1
-	var nibbles = make([]byte, l)
-	for i, b := range str {
-		nibbles[i*2] = b / 16
-		nibbles[i*2+1] = b % 16
-	}
-	nibbles[l-1] = 16
-	return nibbles
-}
-
-func hexToCompact(hex []byte) []byte {
-	terminator := byte(0)
-	if hasTerm(hex) {
-		terminator = 1
-		hex = hex[:len(hex)-1]
-	}
-	buf := make([]byte, len(hex)/2+1)
-	buf[0] = terminator << 5 // the flag byte
-	if len(hex)&1 == 1 {
-		buf[0] |= 1 << 4 // odd flag
-		buf[0] |= hex[0] // first nibble is contained in the first byte
-		hex = hex[1:]
-	}
-	decodeNibbles(hex, buf[1:])
-	return buf
-}
-
-// TestSnapTrieNodes various forms of GetTrieNodes requests.
-func (s *Suite) TestSnapTrieNodes(t *utesting.T) {
-
-	key := common.FromHex("0x00bf49f440a1cd0527e4d06e2765654c0f56452257516d793a9b8d604dcfdf2a")
-	// helper function to iterate the key, and generate the compact-encoded
-	// trie paths along the way.
-	pathTo := func(length int) snap.TrieNodePathSet {
-		hex := keybytesToHex(key)[:length]
-		hex[len(hex)-1] = 0 // remove term flag
-		hKey := hexToCompact(hex)
-		return snap.TrieNodePathSet{hKey}
-	}
-	var accPaths []snap.TrieNodePathSet
-	for i := 1; i <= 65; i++ {
-		accPaths = append(accPaths, pathTo(i))
-	}
-	empty := emptyCode
-	for i, tc := range []trieNodesTest{
-		{
-			root:      s.chain.RootAt(999),
-			paths:     nil,
-			nBytes:    500,
-			expHashes: nil,
-		},
-		{
-			root: s.chain.RootAt(999),
-			paths: []snap.TrieNodePathSet{
-				snap.TrieNodePathSet{}, // zero-length pathset should 'abort' and kick us off
-				snap.TrieNodePathSet{[]byte{0}},
-			},
-			nBytes:    5000,
-			expHashes: []common.Hash{},
-			expReject: true,
-		},
-		{
-			root: s.chain.RootAt(999),
-			paths: []snap.TrieNodePathSet{
-				snap.TrieNodePathSet{[]byte{0}},
-				snap.TrieNodePathSet{[]byte{1}, []byte{0}},
-			},
-			nBytes: 5000,
-			//0x6b3724a41b8c38b46d4d02fba2bb2074c47a507eb16a9a4b978f91d32e406faf
-			expHashes: []common.Hash{s.chain.RootAt(999)},
-		},
-		{ // nonsensically long path
-			root: s.chain.RootAt(999),
-			paths: []snap.TrieNodePathSet{
-				snap.TrieNodePathSet{[]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8,
-					0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 1, 2, 3, 4, 5, 6, 7, 8}},
-			},
-			nBytes:    5000,
-			expHashes: []common.Hash{common.HexToHash("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")},
-		},
-		{
-			root: s.chain.RootAt(0),
-			paths: []snap.TrieNodePathSet{
-				snap.TrieNodePathSet{[]byte{0}},
-				snap.TrieNodePathSet{[]byte{1}, []byte{0}},
-			},
-			nBytes:    5000,
-			expHashes: []common.Hash{},
-		},
-		{
-			// The leaf is only a couple of levels down, so the continued trie traversal causes lookup failures.
-			root:   s.chain.RootAt(999),
-			paths:  accPaths,
-			nBytes: 5000,
-			expHashes: []common.Hash{
-				common.HexToHash("0xbcefee69b37cca1f5bf3a48aebe08b35f2ea1864fa958bb0723d909a0e0d28d8"),
-				common.HexToHash("0x4fb1e4e2391e4b4da471d59641319b8fa25d76c973d4bec594d7b00a69ae5135"),
-				empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty,
-				empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty,
-				empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty,
-				empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty,
-				empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty, empty,
-				empty, empty, empty},
-		},
-		{
-			// Basically the same as above, with different ordering
-			root: s.chain.RootAt(999),
-			paths: []snap.TrieNodePathSet{
-				accPaths[10], accPaths[1], accPaths[0],
-			},
-			nBytes: 5000,
-			expHashes: []common.Hash{
-				empty,
-				common.HexToHash("0x4fb1e4e2391e4b4da471d59641319b8fa25d76c973d4bec594d7b00a69ae5135"),
-				common.HexToHash("0xbcefee69b37cca1f5bf3a48aebe08b35f2ea1864fa958bb0723d909a0e0d28d8"),
-			},
-		},
-	} {
-		if err := s.snapGetTrieNodes(t, &tc); err != nil {
-			t.Errorf("test %d \n #hashes %x\n root: %#x\n bytes: %d\nfailed: %v", i, len(tc.expHashes), tc.root, tc.nBytes, err)
-		}
-	}
-}
-
-func (s *Suite) snapGetAccountRange(t *utesting.T, tc *accRangeTest) error {
-	conn, err := s.dialSnap()
-	if err != nil {
-		t.Fatalf("dial failed: %v", err)
-	}
-	defer conn.Close()
-	if err = conn.peer(s.chain, nil); err != nil {
-		t.Fatalf("peering failed: %v", err)
-	}
-	// write request
-	req := &GetAccountRange{
-		ID:     uint64(rand.Int63()),
-		Root:   tc.root,
-		Origin: tc.origin,
-		Limit:  tc.limit,
-		Bytes:  tc.nBytes,
-	}
-	resp, err := conn.snapRequest(req, req.ID, s.chain)
-	if err != nil {
-		return fmt.Errorf("account range request failed: %v", err)
-	}
-	var res *snap.AccountRangePacket
-	if r, ok := resp.(*AccountRange); !ok {
-		return fmt.Errorf("account range response wrong: %T %v", resp, resp)
-	} else {
-		res = (*snap.AccountRangePacket)(r)
-	}
-	if exp, got := tc.expAccounts, len(res.Accounts); exp != got {
-		return fmt.Errorf("expected %d accounts, got %d", exp, got)
-	}
-	// Check that the encoding order is correct
-	for i := 1; i < len(res.Accounts); i++ {
-		if bytes.Compare(res.Accounts[i-1].Hash[:], res.Accounts[i].Hash[:]) >= 0 {
-			return fmt.Errorf("accounts not monotonically increasing: #%d [%x] vs #%d [%x]", i-1, res.Accounts[i-1].Hash[:], i, res.Accounts[i].Hash[:])
-		}
-	}
-	var (
-		hashes   []common.Hash
-		accounts [][]byte
-		proof    = res.Proof
-	)
-	hashes, accounts, err = res.Unpack()
-	if err != nil {
-		return err
-	}
-	if len(hashes) == 0 && len(accounts) == 0 && len(proof) == 0 {
-		return nil
-	}
-	if len(hashes) > 0 {
-		if exp, got := tc.expFirst, res.Accounts[0].Hash; exp != got {
-			return fmt.Errorf("expected first account 0x%x, got 0x%x", exp, got)
-		}
-		if exp, got := tc.expLast, res.Accounts[len(res.Accounts)-1].Hash; exp != got {
-			return fmt.Errorf("expected last account 0x%x, got 0x%x", exp, got)
-		}
-	}
-	// Reconstruct a partial trie from the response and verify it
-	keys := make([][]byte, len(hashes))
-	for i, key := range hashes {
-		keys[i] = common.CopyBytes(key[:])
-	}
-	nodes := make(light.NodeList, len(proof))
-	for i, node := range proof {
-		nodes[i] = node
-	}
-	proofdb := nodes.NodeSet()
-
-	var end []byte
-	if len(keys) > 0 {
-		end = keys[len(keys)-1]
-	}
-	_, err = trie.VerifyRangeProof(tc.root, tc.origin[:], end, keys, accounts, proofdb)
-	return err
-}
-
-func (s *Suite) snapGetStorageRanges(t *utesting.T, tc *stRangesTest) error {
-	conn, err := s.dialSnap()
-	if err != nil {
-		t.Fatalf("dial failed: %v", err)
-	}
-	defer conn.Close()
-	if err = conn.peer(s.chain, nil); err != nil {
-		t.Fatalf("peering failed: %v", err)
-	}
-	// write request
-	req := &GetStorageRanges{
-		ID:       uint64(rand.Int63()),
-		Root:     tc.root,
-		Accounts: tc.accounts,
-		Origin:   tc.origin,
-		Limit:    tc.limit,
-		Bytes:    tc.nBytes,
-	}
-	resp, err := conn.snapRequest(req, req.ID, s.chain)
-	if err != nil {
-		return fmt.Errorf("account range request failed: %v", err)
-	}
-	var res *snap.StorageRangesPacket
-	if r, ok := resp.(*StorageRanges); !ok {
-		return fmt.Errorf("account range response wrong: %T %v", resp, resp)
-	} else {
-		res = (*snap.StorageRangesPacket)(r)
-	}
-	gotSlots := 0
-	// Ensure the ranges are monotonically increasing
-	for i, slots := range res.Slots {
-		gotSlots += len(slots)
-		for j := 1; j < len(slots); j++ {
-			if bytes.Compare(slots[j-1].Hash[:], slots[j].Hash[:]) >= 0 {
-				return fmt.Errorf("storage slots not monotonically increasing for account #%d: #%d [%x] vs #%d [%x]", i, j-1, slots[j-1].Hash[:], j, slots[j].Hash[:])
-			}
-		}
-	}
-	if exp, got := tc.expSlots, gotSlots; exp != got {
-		return fmt.Errorf("expected %d slots, got %d", exp, got)
-	}
-	return nil
-}
-
-func (s *Suite) snapGetByteCodes(t *utesting.T, tc *byteCodesTest) error {
-	conn, err := s.dialSnap()
-	if err != nil {
-		t.Fatalf("dial failed: %v", err)
-	}
-	defer conn.Close()
-	if err = conn.peer(s.chain, nil); err != nil {
-		t.Fatalf("peering failed: %v", err)
-	}
-	// write request
-	req := &GetByteCodes{
-		ID:     uint64(rand.Int63()),
-		Hashes: tc.hashes,
-		Bytes:  tc.nBytes,
-	}
-	resp, err := conn.snapRequest(req, req.ID, s.chain)
-	if err != nil {
-		return fmt.Errorf("getBytecodes request failed: %v", err)
-	}
-	var res *snap.ByteCodesPacket
-	if r, ok := resp.(*ByteCodes); !ok {
-		return fmt.Errorf("bytecodes response wrong: %T %v", resp, resp)
-	} else {
-		res = (*snap.ByteCodesPacket)(r)
-	}
-	if exp, got := tc.expHashes, len(res.Codes); exp != got {
-		for i, c := range res.Codes {
-			fmt.Printf("%d. %#x\n", i, c)
-		}
-		return fmt.Errorf("expected %d bytecodes, got %d", exp, got)
-	}
-	// Cross reference the requested bytecodes with the response to find gaps
-	// that the serving node is missing
-	var (
-		bytecodes = res.Codes
-		hasher    = sha3.NewLegacyKeccak256().(crypto.KeccakState)
-		hash      = make([]byte, 32)
-		codes     = make([][]byte, len(req.Hashes))
-	)
-
-	for i, j := 0, 0; i < len(bytecodes); i++ {
-		// Find the next hash that we've been served, leaving misses with nils
-		hasher.Reset()
-		hasher.Write(bytecodes[i])
-		hasher.Read(hash)
-
-		for j < len(req.Hashes) && !bytes.Equal(hash, req.Hashes[j][:]) {
-			j++
-		}
-		if j < len(req.Hashes) {
-			codes[j] = bytecodes[i]
-			j++
-			continue
-		}
-		// We've either ran out of hashes, or got unrequested data
-		return errors.New("unexpected bytecode")
-	}
-
-	return nil
-}
-
-func (s *Suite) snapGetTrieNodes(t *utesting.T, tc *trieNodesTest) error {
-	conn, err := s.dialSnap()
-	if err != nil {
-		t.Fatalf("dial failed: %v", err)
-	}
-	defer conn.Close()
-	if err = conn.peer(s.chain, nil); err != nil {
-		t.Fatalf("peering failed: %v", err)
-	}
-	// write request
-	req := &GetTrieNodes{
-		ID:    uint64(rand.Int63()),
-		Root:  tc.root,
-		Paths: tc.paths,
-		Bytes: tc.nBytes,
-	}
-	resp, err := conn.snapRequest(req, req.ID, s.chain)
-	if err != nil {
-		if tc.expReject {
-			return nil
-		}
-		return fmt.Errorf("trienodes  request failed: %v", err)
-	}
-	var res *snap.TrieNodesPacket
-	if r, ok := resp.(*TrieNodes); !ok {
-		return fmt.Errorf("trienodes response wrong: %T %v", resp, resp)
-	} else {
-		res = (*snap.TrieNodesPacket)(r)
-	}
-
-	// Check the correctness
-
-	// Cross reference the requested trienodes with the response to find gaps
-	// that the serving node is missing
-	hasher := sha3.NewLegacyKeccak256().(crypto.KeccakState)
-	hash := make([]byte, 32)
-	trienodes := res.Nodes
-	if got, want := len(trienodes), len(tc.expHashes); got != want {
-		return fmt.Errorf("wrong trienode count, got %d, want %d\n", got, want)
-	}
-	for i, trienode := range trienodes {
-		hasher.Reset()
-		hasher.Write(trienode)
-		hasher.Read(hash)
-		if got, want := hash, tc.expHashes[i]; !bytes.Equal(got, want[:]) {
-			fmt.Printf("hash %d wrong, got %#x, want %#x\n", i, got, want)
-			err = fmt.Errorf("hash %d wrong, got %#x, want %#x", i, got, want)
-		}
-	}
-	return err
-}

cmd/devp2p/internal/ethtest/snapTypes.go

@@ -1,36 +0,0 @@
-package ethtest
-
-import "github.com/ethereum/go-ethereum/eth/protocols/snap"
-
-// GetAccountRange represents an account range query.
-type GetAccountRange snap.GetAccountRangePacket
-
-func (g GetAccountRange) Code() int { return 33 }
-
-type AccountRange snap.AccountRangePacket
-
-func (g AccountRange) Code() int { return 34 }
-
-type GetStorageRanges snap.GetStorageRangesPacket
-
-func (g GetStorageRanges) Code() int { return 35 }
-
-type StorageRanges snap.StorageRangesPacket
-
-func (g StorageRanges) Code() int { return 36 }
-
-type GetByteCodes snap.GetByteCodesPacket
-
-func (g GetByteCodes) Code() int { return 37 }
-
-type ByteCodes snap.ByteCodesPacket
-
-func (g ByteCodes) Code() int { return 38 }
-
-type GetTrieNodes snap.GetTrieNodesPacket
-
-func (g GetTrieNodes) Code() int { return 39 }
-
-type TrieNodes snap.TrieNodesPacket
-
-func (g TrieNodes) Code() int { return 40 }

cmd/devp2p/internal/ethtest/suite.go

@@ -52,35 +52,35 @@ func NewSuite(dest *enode.Node, chainfile string, genesisfile string) (*Suite, e
 func (s *Suite) AllEthTests() []utesting.Test {
 	return []utesting.Test{
 		// status
-		{Name: "TestStatus65", Fn: s.TestStatus65},
+		{Name: "TestStatus", Fn: s.TestStatus},
 		{Name: "TestStatus66", Fn: s.TestStatus66},
 		// get block headers
-		{Name: "TestGetBlockHeaders65", Fn: s.TestGetBlockHeaders65},
+		{Name: "TestGetBlockHeaders", Fn: s.TestGetBlockHeaders},
 		{Name: "TestGetBlockHeaders66", Fn: s.TestGetBlockHeaders66},
 		{Name: "TestSimultaneousRequests66", Fn: s.TestSimultaneousRequests66},
 		{Name: "TestSameRequestID66", Fn: s.TestSameRequestID66},
 		{Name: "TestZeroRequestID66", Fn: s.TestZeroRequestID66},
 		// get block bodies
-		{Name: "TestGetBlockBodies65", Fn: s.TestGetBlockBodies65},
+		{Name: "TestGetBlockBodies", Fn: s.TestGetBlockBodies},
 		{Name: "TestGetBlockBodies66", Fn: s.TestGetBlockBodies66},
 		// broadcast
-		{Name: "TestBroadcast65", Fn: s.TestBroadcast65},
+		{Name: "TestBroadcast", Fn: s.TestBroadcast},
 		{Name: "TestBroadcast66", Fn: s.TestBroadcast66},
-		{Name: "TestLargeAnnounce65", Fn: s.TestLargeAnnounce65},
+		{Name: "TestLargeAnnounce", Fn: s.TestLargeAnnounce},
 		{Name: "TestLargeAnnounce66", Fn: s.TestLargeAnnounce66},
-		{Name: "TestOldAnnounce65", Fn: s.TestOldAnnounce65},
+		{Name: "TestOldAnnounce", Fn: s.TestOldAnnounce},
 		{Name: "TestOldAnnounce66", Fn: s.TestOldAnnounce66},
-		{Name: "TestBlockHashAnnounce65", Fn: s.TestBlockHashAnnounce65},
+		{Name: "TestBlockHashAnnounce", Fn: s.TestBlockHashAnnounce},
 		{Name: "TestBlockHashAnnounce66", Fn: s.TestBlockHashAnnounce66},
 		// malicious handshakes + status
-		{Name: "TestMaliciousHandshake65", Fn: s.TestMaliciousHandshake65},
+		{Name: "TestMaliciousHandshake", Fn: s.TestMaliciousHandshake},
-		{Name: "TestMaliciousStatus65", Fn: s.TestMaliciousStatus65},
+		{Name: "TestMaliciousStatus", Fn: s.TestMaliciousStatus},
 		{Name: "TestMaliciousHandshake66", Fn: s.TestMaliciousHandshake66},
 		{Name: "TestMaliciousStatus66", Fn: s.TestMaliciousStatus66},
 		// test transactions
-		{Name: "TestTransaction65", Fn: s.TestTransaction65},
+		{Name: "TestTransaction", Fn: s.TestTransaction},
 		{Name: "TestTransaction66", Fn: s.TestTransaction66},
-		{Name: "TestMaliciousTx65", Fn: s.TestMaliciousTx65},
+		{Name: "TestMaliciousTx", Fn: s.TestMaliciousTx},
 		{Name: "TestMaliciousTx66", Fn: s.TestMaliciousTx66},
 		{Name: "TestLargeTxRequest66", Fn: s.TestLargeTxRequest66},
 		{Name: "TestNewPooledTxs66", Fn: s.TestNewPooledTxs66},
@@ -89,17 +89,17 @@ func (s *Suite) AllEthTests() []utesting.Test {
 
 func (s *Suite) EthTests() []utesting.Test {
 	return []utesting.Test{
-		{Name: "TestStatus65", Fn: s.TestStatus65},
+		{Name: "TestStatus", Fn: s.TestStatus},
-		{Name: "TestGetBlockHeaders65", Fn: s.TestGetBlockHeaders65},
+		{Name: "TestGetBlockHeaders", Fn: s.TestGetBlockHeaders},
-		{Name: "TestGetBlockBodies65", Fn: s.TestGetBlockBodies65},
+		{Name: "TestGetBlockBodies", Fn: s.TestGetBlockBodies},
-		{Name: "TestBroadcast65", Fn: s.TestBroadcast65},
+		{Name: "TestBroadcast", Fn: s.TestBroadcast},
-		{Name: "TestLargeAnnounce65", Fn: s.TestLargeAnnounce65},
+		{Name: "TestLargeAnnounce", Fn: s.TestLargeAnnounce},
-		{Name: "TestOldAnnounce65", Fn: s.TestOldAnnounce65},
+		{Name: "TestOldAnnounce", Fn: s.TestOldAnnounce},
-		{Name: "TestBlockHashAnnounce65", Fn: s.TestBlockHashAnnounce65},
+		{Name: "TestBlockHashAnnounce", Fn: s.TestBlockHashAnnounce},
-		{Name: "TestMaliciousHandshake65", Fn: s.TestMaliciousHandshake65},
+		{Name: "TestMaliciousHandshake", Fn: s.TestMaliciousHandshake},
-		{Name: "TestMaliciousStatus65", Fn: s.TestMaliciousStatus65},
+		{Name: "TestMaliciousStatus", Fn: s.TestMaliciousStatus},
-		{Name: "TestTransaction65", Fn: s.TestTransaction65},
+		{Name: "TestTransaction", Fn: s.TestTransaction},
-		{Name: "TestMaliciousTx65", Fn: s.TestMaliciousTx65},
+		{Name: "TestMaliciousTx", Fn: s.TestMaliciousTx},
 	}
 }
 
@@ -125,24 +125,14 @@ func (s *Suite) Eth66Tests() []utesting.Test {
 	}
 }
 
-func (s *Suite) SnapTests() []utesting.Test {
-	return []utesting.Test{
-		{Name: "TestSnapStatus", Fn: s.TestSnapStatus},
-		{Name: "TestSnapAccountRange", Fn: s.TestSnapGetAccountRange},
-		{Name: "TestSnapGetByteCodes", Fn: s.TestSnapGetByteCodes},
-		{Name: "TestSnapGetTrieNodes", Fn: s.TestSnapTrieNodes},
-		{Name: "TestSnapGetStorageRanges", Fn: s.TestSnapGetStorageRanges},
-	}
-}
-
 var (
 	eth66 = true  // indicates whether suite should negotiate eth66 connection
 	eth65 = false // indicates whether suite should negotiate eth65 connection or below.
 )
 
-// TestStatus65 attempts to connect to the given node and exchange
+// TestStatus attempts to connect to the given node and exchange
 // a status message with it.
-func (s *Suite) TestStatus65(t *utesting.T) {
+func (s *Suite) TestStatus(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -166,9 +156,9 @@ func (s *Suite) TestStatus66(t *utesting.T) {
 	}
 }
 
-// TestGetBlockHeaders65 tests whether the given node can respond to
+// TestGetBlockHeaders tests whether the given node can respond to
 // a `GetBlockHeaders` request accurately.
-func (s *Suite) TestGetBlockHeaders65(t *utesting.T) {
+func (s *Suite) TestGetBlockHeaders(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -402,9 +392,9 @@ func (s *Suite) TestZeroRequestID66(t *utesting.T) {
 	}
 }
 
-// TestGetBlockBodies65 tests whether the given node can respond to
+// TestGetBlockBodies tests whether the given node can respond to
 // a `GetBlockBodies` request and that the response is accurate.
-func (s *Suite) TestGetBlockBodies65(t *utesting.T) {
+func (s *Suite) TestGetBlockBodies(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -470,9 +460,9 @@ func (s *Suite) TestGetBlockBodies66(t *utesting.T) {
 	}
 }
 
-// TestBroadcast65 tests whether a block announcement is correctly
+// TestBroadcast tests whether a block announcement is correctly
 // propagated to the given node's peer(s).
-func (s *Suite) TestBroadcast65(t *utesting.T) {
+func (s *Suite) TestBroadcast(t *utesting.T) {
 	if err := s.sendNextBlock(eth65); err != nil {
 		t.Fatalf("block broadcast failed: %v", err)
 	}
@@ -486,8 +476,8 @@ func (s *Suite) TestBroadcast66(t *utesting.T) {
 	}
 }
 
-// TestLargeAnnounce65 tests the announcement mechanism with a large block.
+// TestLargeAnnounce tests the announcement mechanism with a large block.
-func (s *Suite) TestLargeAnnounce65(t *utesting.T) {
+func (s *Suite) TestLargeAnnounce(t *utesting.T) {
 	nextBlock := len(s.chain.blocks)
 	blocks := []*NewBlock{
 		{
@@ -579,8 +569,8 @@ func (s *Suite) TestLargeAnnounce66(t *utesting.T) {
 	}
 }
 
-// TestOldAnnounce65 tests the announcement mechanism with an old block.
+// TestOldAnnounce tests the announcement mechanism with an old block.
-func (s *Suite) TestOldAnnounce65(t *utesting.T) {
+func (s *Suite) TestOldAnnounce(t *utesting.T) {
 	if err := s.oldAnnounce(eth65); err != nil {
 		t.Fatal(err)
 	}
@@ -594,9 +584,9 @@ func (s *Suite) TestOldAnnounce66(t *utesting.T) {
 	}
 }
 
-// TestBlockHashAnnounce65 sends a new block hash announcement and expects
+// TestBlockHashAnnounce sends a new block hash announcement and expects
 // the node to perform a `GetBlockHeaders` request.
-func (s *Suite) TestBlockHashAnnounce65(t *utesting.T) {
+func (s *Suite) TestBlockHashAnnounce(t *utesting.T) {
 	if err := s.hashAnnounce(eth65); err != nil {
 		t.Fatalf("block hash announcement failed: %v", err)
 	}
@@ -610,8 +600,8 @@ func (s *Suite) TestBlockHashAnnounce66(t *utesting.T) {
 	}
 }
 
-// TestMaliciousHandshake65 tries to send malicious data during the handshake.
+// TestMaliciousHandshake tries to send malicious data during the handshake.
-func (s *Suite) TestMaliciousHandshake65(t *utesting.T) {
+func (s *Suite) TestMaliciousHandshake(t *utesting.T) {
 	if err := s.maliciousHandshakes(t, eth65); err != nil {
 		t.Fatal(err)
 	}
@@ -624,8 +614,8 @@ func (s *Suite) TestMaliciousHandshake66(t *utesting.T) {
 	}
 }
 
-// TestMaliciousStatus65 sends a status package with a large total difficulty.
+// TestMaliciousStatus sends a status package with a large total difficulty.
-func (s *Suite) TestMaliciousStatus65(t *utesting.T) {
+func (s *Suite) TestMaliciousStatus(t *utesting.T) {
 	conn, err := s.dial()
 	if err != nil {
 		t.Fatalf("dial failed: %v", err)
@@ -651,9 +641,9 @@ func (s *Suite) TestMaliciousStatus66(t *utesting.T) {
 	}
 }
 
-// TestTransaction65 sends a valid transaction to the node and
+// TestTransaction sends a valid transaction to the node and
 // checks if the transaction gets propagated.
-func (s *Suite) TestTransaction65(t *utesting.T) {
+func (s *Suite) TestTransaction(t *utesting.T) {
 	if err := s.sendSuccessfulTxs(t, eth65); err != nil {
 		t.Fatal(err)
 	}
@@ -667,9 +657,9 @@ func (s *Suite) TestTransaction66(t *utesting.T) {
 	}
 }
 
-// TestMaliciousTx65 sends several invalid transactions and tests whether
+// TestMaliciousTx sends several invalid transactions and tests whether
 // the node will propagate them.
-func (s *Suite) TestMaliciousTx65(t *utesting.T) {
+func (s *Suite) TestMaliciousTx(t *utesting.T) {
 	if err := s.sendMaliciousTxs(t, eth65); err != nil {
 		t.Fatal(err)
 	}

cmd/devp2p/internal/ethtest/suite_test.go

@@ -45,28 +45,7 @@ func TestEthSuite(t *testing.T) {
 	if err != nil {
 		t.Fatalf("could not create new test suite: %v", err)
 	}
-	for _, test := range suite.Eth66Tests() {
+	for _, test := range suite.AllEthTests() {
-		t.Run(test.Name, func(t *testing.T) {
-			result := utesting.RunTAP([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
-			if result[0].Failed {
-				t.Fatal()
-			}
-		})
-	}
-}
-
-func TestSnapSuite(t *testing.T) {
-	geth, err := runGeth()
-	if err != nil {
-		t.Fatalf("could not run geth: %v", err)
-	}
-	defer geth.Close()
-
-	suite, err := NewSuite(geth.Server().Self(), fullchainFile, genesisFile)
-	if err != nil {
-		t.Fatalf("could not create new test suite: %v", err)
-	}
-	for _, test := range suite.SnapTests() {
 		t.Run(test.Name, func(t *testing.T) {
 			result := utesting.RunTAP([]utesting.Test{{Name: test.Name, Fn: test.Fn}}, os.Stdout)
 			if result[0].Failed {

cmd/devp2p/internal/ethtest/types.go

@@ -19,7 +19,6 @@ package ethtest
 import (
 	"crypto/ecdsa"
 	"fmt"
-	"time"
 
 	"github.com/ethereum/go-ethereum/eth/protocols/eth"
 	"github.com/ethereum/go-ethereum/p2p"
@@ -127,12 +126,10 @@ func (pt PooledTransactions) Code() int { return 26 }
 // Conn represents an individual connection with a peer
 type Conn struct {
 	*rlpx.Conn
-	ourKey                     *ecdsa.PrivateKey
+	ourKey                 *ecdsa.PrivateKey
-	negotiatedProtoVersion     uint
+	negotiatedProtoVersion uint
-	negotiatedSnapProtoVersion uint
+	ourHighestProtoVersion uint
-	ourHighestProtoVersion     uint
+	caps                   []p2p.Cap
-	ourHighestSnapProtoVersion uint
-	caps                       []p2p.Cap
 }
 
 // Read reads an eth packet from the connection.
@@ -262,7 +259,12 @@ func (c *Conn) Read66() (uint64, Message) {
 
 // Write writes a eth packet to the connection.
 func (c *Conn) Write(msg Message) error {
-	payload, err := rlp.EncodeToBytes(msg)
+	// check if message is eth protocol message
+	var (
+		payload []byte
+		err     error
+	)
+	payload, err = rlp.EncodeToBytes(msg)
 	if err != nil {
 		return err
 	}
@@ -279,43 +281,3 @@ func (c *Conn) Write66(req eth.Packet, code int) error {
 	_, err = c.Conn.Write(uint64(code), payload)
 	return err
 }
-
-// ReadSnap reads a snap/1 response with the given id from the connection.
-func (c *Conn) ReadSnap(id uint64) (Message, error) {
-	respId := id + 1
-	start := time.Now()
-	for respId != id && time.Since(start) < timeout {
-		code, rawData, _, err := c.Conn.Read()
-		if err != nil {
-			return nil, fmt.Errorf("could not read from connection: %v", err)
-		}
-		var snpMsg interface{}
-		switch int(code) {
-		case (GetAccountRange{}).Code():
-			snpMsg = new(GetAccountRange)
-		case (AccountRange{}).Code():
-			snpMsg = new(AccountRange)
-		case (GetStorageRanges{}).Code():
-			snpMsg = new(GetStorageRanges)
-		case (StorageRanges{}).Code():
-			snpMsg = new(StorageRanges)
-		case (GetByteCodes{}).Code():
-			snpMsg = new(GetByteCodes)
-		case (ByteCodes{}).Code():
-			snpMsg = new(ByteCodes)
-		case (GetTrieNodes{}).Code():
-			snpMsg = new(GetTrieNodes)
-		case (TrieNodes{}).Code():
-			snpMsg = new(TrieNodes)
-		default:
-			//return nil, fmt.Errorf("invalid message code: %d", code)
-			continue
-		}
-		if err := rlp.DecodeBytes(rawData, snpMsg); err != nil {
-			return nil, fmt.Errorf("could not rlp decode message: %v", err)
-		}
-		return snpMsg.(Message), nil
-
-	}
-	return nil, fmt.Errorf("request timed out")
-}

cmd/devp2p/internal/v4test/discv4tests.go

@@ -229,7 +229,7 @@ func PingPastExpiration(t *utesting.T) {
 
 	reply, _, _ := te.read(te.l1)
 	if reply != nil {
-		t.Fatalf("Expected no reply, got %v %v", reply.Name(), reply)
+		t.Fatal("Expected no reply, got", reply)
 	}
 }
 
@@ -247,7 +247,7 @@ func WrongPacketType(t *utesting.T) {
 
 	reply, _, _ := te.read(te.l1)
 	if reply != nil {
-		t.Fatalf("Expected no reply, got %v %v", reply.Name(), reply)
+		t.Fatal("Expected no reply, got", reply)
 	}
 }
 
@@ -282,16 +282,9 @@ func FindnodeWithoutEndpointProof(t *utesting.T) {
 	rand.Read(req.Target[:])
 	te.send(te.l1, &req)
 
-	for {
+	reply, _, _ := te.read(te.l1)
-		reply, _, _ := te.read(te.l1)
+	if reply != nil {
-		if reply == nil {
+		t.Fatal("Expected no response, got", reply)
-			// No response, all good
-			break
-		}
-		if reply.Kind() == v4wire.PingPacket {
-			continue // A ping is ok, just ignore it
-		}
-		t.Fatalf("Expected no reply, got %v %v", reply.Name(), reply)
 	}
 }
 
@@ -311,7 +304,7 @@ func BasicFindnode(t *utesting.T) {
 		t.Fatal("read find nodes", err)
 	}
 	if reply.Kind() != v4wire.NeighborsPacket {
-		t.Fatalf("Expected neighbors, got %v %v", reply.Name(), reply)
+		t.Fatal("Expected neighbors, got", reply.Name())
 	}
 }
 
@@ -348,7 +341,7 @@ func UnsolicitedNeighbors(t *utesting.T) {
 		t.Fatal("read find nodes", err)
 	}
 	if reply.Kind() != v4wire.NeighborsPacket {
-		t.Fatalf("Expected neighbors, got %v %v", reply.Name(), reply)
+		t.Fatal("Expected neighbors, got", reply.Name())
 	}
 	nodes := reply.(*v4wire.Neighbors).Nodes
 	if contains(nodes, encFakeKey) {

cmd/devp2p/nodesetcmd.go

@@ -235,8 +235,6 @@ func ethFilter(args []string) (nodeFilter, error) {
 		filter = forkid.NewStaticFilter(params.GoerliChainConfig, params.GoerliGenesisHash)
 	case "ropsten":
 		filter = forkid.NewStaticFilter(params.RopstenChainConfig, params.RopstenGenesisHash)
-	case "sepolia":
-		filter = forkid.NewStaticFilter(params.SepoliaChainConfig, params.SepoliaGenesisHash)
 	default:
 		return nil, fmt.Errorf("unknown network %q", args[0])
 	}

cmd/devp2p/rlpxcmd.go

@@ -36,7 +36,6 @@ var (
 		Subcommands: []cli.Command{
 			rlpxPingCommand,
 			rlpxEthTestCommand,
-			rlpxSnapTestCommand,
 		},
 	}
 	rlpxPingCommand = cli.Command{
@@ -54,16 +53,6 @@ var (
 			testTAPFlag,
 		},
 	}
-	rlpxSnapTestCommand = cli.Command{
-		Name:      "snap-test",
-		Usage:     "Runs tests against a node",
-		ArgsUsage: "<node> <chain.rlp> <genesis.json>",
-		Action:    rlpxSnapTest,
-		Flags: []cli.Flag{
-			testPatternFlag,
-			testTAPFlag,
-		},
-	}
 )
 
 func rlpxPing(ctx *cli.Context) error {
@@ -117,15 +106,3 @@ func rlpxEthTest(ctx *cli.Context) error {
 	}
 	return runTests(ctx, suite.AllEthTests())
 }
-
-// rlpxSnapTest runs the snap protocol test suite.
-func rlpxSnapTest(ctx *cli.Context) error {
-	if ctx.NArg() < 3 {
-		exit("missing path to chain.rlp as command-line argument")
-	}
-	suite, err := ethtest.NewSuite(getNodeArg(ctx), ctx.Args()[1], ctx.Args()[2])
-	if err != nil {
-		exit(err)
-	}
-	return runTests(ctx, suite.SnapTests())
-}

cmd/ethkey/message_test.go

@@ -17,12 +17,18 @@
 package main
 
 import (
+	"io/ioutil"
+	"os"
 	"path/filepath"
 	"testing"
 )
 
 func TestMessageSignVerify(t *testing.T) {
-	tmpdir := t.TempDir()
+	tmpdir, err := ioutil.TempDir("", "ethkey-test")
+	if err != nil {
+		t.Fatal("Can't create temporary directory:", err)
+	}
+	defer os.RemoveAll(tmpdir)
 
 	keyfile := filepath.Join(tmpdir, "the-keyfile")
 	message := "test message"

cmd/ethkey/utils.go

@@ -49,7 +49,7 @@ func getPassphrase(ctx *cli.Context, confirmation bool) string {
 // signHash 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 calculated as
+// 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.

cmd/evm/README.md

@@ -208,7 +208,7 @@ Example:
   ]
 }
 ```
-When applying this, using a reward of `0x80`
+When applying this, using a reward of `0x08`
 Output:
 ```json
 {

cmd/evm/disasm.go

@@ -46,7 +46,7 @@ func disasmCmd(ctx *cli.Context) error {
 	case ctx.GlobalIsSet(InputFlag.Name):
 		in = ctx.GlobalString(InputFlag.Name)
 	default:
-		return errors.New("missing filename or --input value")
+		return errors.New("Missing filename or --input value")
 	}
 
 	code := strings.TrimSpace(in)

cmd/evm/internal/t8ntool/block.go

@@ -1,380 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum 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.
-//
-// go-ethereum 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 go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package t8ntool
-
-import (
-	"crypto/ecdsa"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-	"os"
-
-	"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/clique"
-	"github.com/ethereum/go-ethereum/consensus/ethash"
-	"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"
-	"gopkg.in/urfave/cli.v1"
-)
-
-//go:generate go run github.com/fjl/gencodec -type header -field-override headerMarshaling -out gen_header.go
-type header struct {
-	ParentHash  common.Hash       `json:"parentHash"`
-	OmmerHash   *common.Hash      `json:"sha3Uncles"`
-	Coinbase    *common.Address   `json:"miner"`
-	Root        common.Hash       `json:"stateRoot"        gencodec:"required"`
-	TxHash      *common.Hash      `json:"transactionsRoot"`
-	ReceiptHash *common.Hash      `json:"receiptsRoot"`
-	Bloom       types.Bloom       `json:"logsBloom"`
-	Difficulty  *big.Int          `json:"difficulty"`
-	Number      *big.Int          `json:"number"           gencodec:"required"`
-	GasLimit    uint64            `json:"gasLimit"         gencodec:"required"`
-	GasUsed     uint64            `json:"gasUsed"`
-	Time        uint64            `json:"timestamp"        gencodec:"required"`
-	Extra       []byte            `json:"extraData"`
-	MixDigest   common.Hash       `json:"mixHash"`
-	Nonce       *types.BlockNonce `json:"nonce"`
-	BaseFee     *big.Int          `json:"baseFeePerGas" rlp:"optional"`
-}
-
-type headerMarshaling struct {
-	Difficulty *math.HexOrDecimal256
-	Number     *math.HexOrDecimal256
-	GasLimit   math.HexOrDecimal64
-	GasUsed    math.HexOrDecimal64
-	Time       math.HexOrDecimal64
-	Extra      hexutil.Bytes
-	BaseFee    *math.HexOrDecimal256
-}
-
-type bbInput struct {
-	Header    *header      `json:"header,omitempty"`
-	OmmersRlp []string     `json:"ommers,omitempty"`
-	TxRlp     string       `json:"txs,omitempty"`
-	Clique    *cliqueInput `json:"clique,omitempty"`
-
-	Ethash    bool                 `json:"-"`
-	EthashDir string               `json:"-"`
-	PowMode   ethash.Mode          `json:"-"`
-	Txs       []*types.Transaction `json:"-"`
-	Ommers    []*types.Header      `json:"-"`
-}
-
-type cliqueInput struct {
-	Key       *ecdsa.PrivateKey
-	Voted     *common.Address
-	Authorize *bool
-	Vanity    common.Hash
-}
-
-// UnmarshalJSON implements json.Unmarshaler interface.
-func (c *cliqueInput) UnmarshalJSON(input []byte) error {
-	var x struct {
-		Key       *common.Hash    `json:"secretKey"`
-		Voted     *common.Address `json:"voted"`
-		Authorize *bool           `json:"authorize"`
-		Vanity    common.Hash     `json:"vanity"`
-	}
-	if err := json.Unmarshal(input, &x); err != nil {
-		return err
-	}
-	if x.Key == nil {
-		return errors.New("missing required field 'secretKey' for cliqueInput")
-	}
-	if ecdsaKey, err := crypto.ToECDSA(x.Key[:]); err != nil {
-		return err
-	} else {
-		c.Key = ecdsaKey
-	}
-	c.Voted = x.Voted
-	c.Authorize = x.Authorize
-	c.Vanity = x.Vanity
-	return nil
-}
-
-// ToBlock converts i into a *types.Block
-func (i *bbInput) ToBlock() *types.Block {
-	header := &types.Header{
-		ParentHash:  i.Header.ParentHash,
-		UncleHash:   types.EmptyUncleHash,
-		Coinbase:    common.Address{},
-		Root:        i.Header.Root,
-		TxHash:      types.EmptyRootHash,
-		ReceiptHash: types.EmptyRootHash,
-		Bloom:       i.Header.Bloom,
-		Difficulty:  common.Big0,
-		Number:      i.Header.Number,
-		GasLimit:    i.Header.GasLimit,
-		GasUsed:     i.Header.GasUsed,
-		Time:        i.Header.Time,
-		Extra:       i.Header.Extra,
-		MixDigest:   i.Header.MixDigest,
-		BaseFee:     i.Header.BaseFee,
-	}
-
-	// Fill optional values.
-	if i.Header.OmmerHash != nil {
-		header.UncleHash = *i.Header.OmmerHash
-	} else if len(i.Ommers) != 0 {
-		// Calculate the ommer hash if none is provided and there are ommers to hash
-		header.UncleHash = types.CalcUncleHash(i.Ommers)
-	}
-	if i.Header.Coinbase != nil {
-		header.Coinbase = *i.Header.Coinbase
-	}
-	if i.Header.TxHash != nil {
-		header.TxHash = *i.Header.TxHash
-	}
-	if i.Header.ReceiptHash != nil {
-		header.ReceiptHash = *i.Header.ReceiptHash
-	}
-	if i.Header.Nonce != nil {
-		header.Nonce = *i.Header.Nonce
-	}
-	if header.Difficulty != nil {
-		header.Difficulty = i.Header.Difficulty
-	}
-	return types.NewBlockWithHeader(header).WithBody(i.Txs, i.Ommers)
-}
-
-// SealBlock seals the given block using the configured engine.
-func (i *bbInput) SealBlock(block *types.Block) (*types.Block, error) {
-	switch {
-	case i.Ethash:
-		return i.sealEthash(block)
-	case i.Clique != nil:
-		return i.sealClique(block)
-	default:
-		return block, nil
-	}
-}
-
-// sealEthash seals the given block using ethash.
-func (i *bbInput) sealEthash(block *types.Block) (*types.Block, error) {
-	if i.Header.Nonce != nil {
-		return nil, NewError(ErrorConfig, fmt.Errorf("sealing with ethash will overwrite provided nonce"))
-	}
-	ethashConfig := ethash.Config{
-		PowMode:        i.PowMode,
-		DatasetDir:     i.EthashDir,
-		CacheDir:       i.EthashDir,
-		DatasetsInMem:  1,
-		DatasetsOnDisk: 2,
-		CachesInMem:    2,
-		CachesOnDisk:   3,
-	}
-	engine := ethash.New(ethashConfig, nil, true)
-	defer engine.Close()
-	// Use a buffered chan for results.
-	// If the testmode is used, the sealer will return quickly, and complain
-	// "Sealing result is not read by miner" if it cannot write the result.
-	results := make(chan *types.Block, 1)
-	if err := engine.Seal(nil, block, results, nil); err != nil {
-		panic(fmt.Sprintf("failed to seal block: %v", err))
-	}
-	found := <-results
-	return block.WithSeal(found.Header()), nil
-}
-
-// sealClique seals the given block using clique.
-func (i *bbInput) sealClique(block *types.Block) (*types.Block, error) {
-	// If any clique value overwrites an explicit header value, fail
-	// to avoid silently building a block with unexpected values.
-	if i.Header.Extra != nil {
-		return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique will overwrite provided extra data"))
-	}
-	header := block.Header()
-	if i.Clique.Voted != nil {
-		if i.Header.Coinbase != nil {
-			return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided coinbase"))
-		}
-		header.Coinbase = *i.Clique.Voted
-	}
-	if i.Clique.Authorize != nil {
-		if i.Header.Nonce != nil {
-			return nil, NewError(ErrorConfig, fmt.Errorf("sealing with clique and voting will overwrite provided nonce"))
-		}
-		if *i.Clique.Authorize {
-			header.Nonce = [8]byte{}
-		} else {
-			header.Nonce = [8]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
-		}
-	}
-	// Extra is fixed 32 byte vanity and 65 byte signature
-	header.Extra = make([]byte, 32+65)
-	copy(header.Extra[0:32], i.Clique.Vanity.Bytes()[:])
-
-	// Sign the seal hash and fill in the rest of the extra data
-	h := clique.SealHash(header)
-	sighash, err := crypto.Sign(h[:], i.Clique.Key)
-	if err != nil {
-		return nil, err
-	}
-	copy(header.Extra[32:], sighash)
-	block = block.WithSeal(header)
-	return block, nil
-}
-
-// BuildBlock constructs a block from the given inputs.
-func BuildBlock(ctx *cli.Context) error {
-	// Configure the go-ethereum logger
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
-	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
-	log.Root().SetHandler(glogger)
-
-	baseDir, err := createBasedir(ctx)
-	if err != nil {
-		return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err))
-	}
-	inputData, err := readInput(ctx)
-	if err != nil {
-		return err
-	}
-	block := inputData.ToBlock()
-	block, err = inputData.SealBlock(block)
-	if err != nil {
-		return err
-	}
-	return dispatchBlock(ctx, baseDir, block)
-}
-
-func readInput(ctx *cli.Context) (*bbInput, error) {
-	var (
-		headerStr  = ctx.String(InputHeaderFlag.Name)
-		ommersStr  = ctx.String(InputOmmersFlag.Name)
-		txsStr     = ctx.String(InputTxsRlpFlag.Name)
-		cliqueStr  = ctx.String(SealCliqueFlag.Name)
-		ethashOn   = ctx.Bool(SealEthashFlag.Name)
-		ethashDir  = ctx.String(SealEthashDirFlag.Name)
-		ethashMode = ctx.String(SealEthashModeFlag.Name)
-		inputData  = &bbInput{}
-	)
-	if ethashOn && cliqueStr != "" {
-		return nil, NewError(ErrorConfig, fmt.Errorf("both ethash and clique sealing specified, only one may be chosen"))
-	}
-	if ethashOn {
-		inputData.Ethash = ethashOn
-		inputData.EthashDir = ethashDir
-		switch ethashMode {
-		case "normal":
-			inputData.PowMode = ethash.ModeNormal
-		case "test":
-			inputData.PowMode = ethash.ModeTest
-		case "fake":
-			inputData.PowMode = ethash.ModeFake
-		default:
-			return nil, NewError(ErrorConfig, fmt.Errorf("unknown pow mode: %s, supported modes: test, fake, normal", ethashMode))
-		}
-	}
-	if headerStr == stdinSelector || ommersStr == stdinSelector || txsStr == stdinSelector || cliqueStr == stdinSelector {
-		decoder := json.NewDecoder(os.Stdin)
-		if err := decoder.Decode(inputData); err != nil {
-			return nil, NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err))
-		}
-	}
-	if cliqueStr != stdinSelector && cliqueStr != "" {
-		var clique cliqueInput
-		if err := readFile(cliqueStr, "clique", &clique); err != nil {
-			return nil, err
-		}
-		inputData.Clique = &clique
-	}
-	if headerStr != stdinSelector {
-		var env header
-		if err := readFile(headerStr, "header", &env); err != nil {
-			return nil, err
-		}
-		inputData.Header = &env
-	}
-	if ommersStr != stdinSelector && ommersStr != "" {
-		var ommers []string
-		if err := readFile(ommersStr, "ommers", &ommers); err != nil {
-			return nil, err
-		}
-		inputData.OmmersRlp = ommers
-	}
-	if txsStr != stdinSelector {
-		var txs string
-		if err := readFile(txsStr, "txs", &txs); err != nil {
-			return nil, err
-		}
-		inputData.TxRlp = txs
-	}
-	// Deserialize rlp txs and ommers
-	var (
-		ommers = []*types.Header{}
-		txs    = []*types.Transaction{}
-	)
-	if inputData.TxRlp != "" {
-		if err := rlp.DecodeBytes(common.FromHex(inputData.TxRlp), &txs); err != nil {
-			return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode transaction from rlp data: %v", err))
-		}
-		inputData.Txs = txs
-	}
-	for _, str := range inputData.OmmersRlp {
-		type extblock struct {
-			Header *types.Header
-			Txs    []*types.Transaction
-			Ommers []*types.Header
-		}
-		var ommer *extblock
-		if err := rlp.DecodeBytes(common.FromHex(str), &ommer); err != nil {
-			return nil, NewError(ErrorRlp, fmt.Errorf("unable to decode ommer from rlp data: %v", err))
-		}
-		ommers = append(ommers, ommer.Header)
-	}
-	inputData.Ommers = ommers
-
-	return inputData, nil
-}
-
-// dispatchOutput writes the output data to either stderr or stdout, or to the specified
-// files
-func dispatchBlock(ctx *cli.Context, baseDir string, block *types.Block) error {
-	raw, _ := rlp.EncodeToBytes(block)
-
-	type blockInfo struct {
-		Rlp  hexutil.Bytes `json:"rlp"`
-		Hash common.Hash   `json:"hash"`
-	}
-	var enc blockInfo
-	enc.Rlp = raw
-	enc.Hash = block.Hash()
-
-	b, err := json.MarshalIndent(enc, "", "  ")
-	if err != nil {
-		return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err))
-	}
-	switch dest := ctx.String(OutputBlockFlag.Name); dest {
-	case "stdout":
-		os.Stdout.Write(b)
-		os.Stdout.WriteString("\n")
-	case "stderr":
-		os.Stderr.Write(b)
-		os.Stderr.WriteString("\n")
-	default:
-		if err := saveFile(baseDir, dest, enc); err != nil {
-			return err
-		}
-	}
-	return nil
-}

cmd/evm/internal/t8ntool/execution.go

@@ -23,7 +23,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
-	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/consensus/misc"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -47,15 +46,13 @@ type Prestate struct {
 // ExecutionResult contains the execution status after running a state test, any
 // error that might have occurred and a dump of the final state if requested.
 type ExecutionResult struct {
-	StateRoot   common.Hash           `json:"stateRoot"`
+	StateRoot   common.Hash    `json:"stateRoot"`
-	TxRoot      common.Hash           `json:"txRoot"`
+	TxRoot      common.Hash    `json:"txRoot"`
-	ReceiptRoot common.Hash           `json:"receiptsRoot"`
+	ReceiptRoot common.Hash    `json:"receiptRoot"`
-	LogsHash    common.Hash           `json:"logsHash"`
+	LogsHash    common.Hash    `json:"logsHash"`
-	Bloom       types.Bloom           `json:"logsBloom"        gencodec:"required"`
+	Bloom       types.Bloom    `json:"logsBloom"        gencodec:"required"`
-	Receipts    types.Receipts        `json:"receipts"`
+	Receipts    types.Receipts `json:"receipts"`
-	Rejected    []*rejectedTx         `json:"rejected,omitempty"`
+	Rejected    []*rejectedTx  `json:"rejected,omitempty"`
-	Difficulty  *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"`
-	GasUsed     math.HexOrDecimal64   `json:"gasUsed"`
 }
 
 type ommer struct {
@@ -63,32 +60,25 @@ type ommer struct {
 	Address common.Address `json:"address"`
 }
 
-//go:generate go run github.com/fjl/gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
+//go:generate gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go
 type stEnv struct {
-	Coinbase         common.Address                      `json:"currentCoinbase"   gencodec:"required"`
+	Coinbase    common.Address                      `json:"currentCoinbase"   gencodec:"required"`
-	Difficulty       *big.Int                            `json:"currentDifficulty"`
+	Difficulty  *big.Int                            `json:"currentDifficulty" gencodec:"required"`
-	Random           *big.Int                            `json:"currentRandom"`
+	GasLimit    uint64                              `json:"currentGasLimit"   gencodec:"required"`
-	ParentDifficulty *big.Int                            `json:"parentDifficulty"`
+	Number      uint64                              `json:"currentNumber"     gencodec:"required"`
-	GasLimit         uint64                              `json:"currentGasLimit"   gencodec:"required"`
+	Timestamp   uint64                              `json:"currentTimestamp"  gencodec:"required"`
-	Number           uint64                              `json:"currentNumber"     gencodec:"required"`
+	BlockHashes map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-	Timestamp        uint64                              `json:"currentTimestamp"  gencodec:"required"`
+	Ommers      []ommer                             `json:"ommers,omitempty"`
-	ParentTimestamp  uint64                              `json:"parentTimestamp,omitempty"`
+	BaseFee     *big.Int                            `json:"currentBaseFee,omitempty"`
-	BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-	Ommers           []ommer                             `json:"ommers,omitempty"`
-	BaseFee          *big.Int                            `json:"currentBaseFee,omitempty"`
-	ParentUncleHash  common.Hash                         `json:"parentUncleHash"`
 }
 
 type stEnvMarshaling struct {
-	Coinbase         common.UnprefixedAddress
+	Coinbase   common.UnprefixedAddress
-	Difficulty       *math.HexOrDecimal256
+	Difficulty *math.HexOrDecimal256
-	Random           *math.HexOrDecimal256
+	GasLimit   math.HexOrDecimal64
-	ParentDifficulty *math.HexOrDecimal256
+	Number     math.HexOrDecimal64
-	GasLimit         math.HexOrDecimal64
+	Timestamp  math.HexOrDecimal64
-	Number           math.HexOrDecimal64
+	BaseFee    *math.HexOrDecimal256
-	Timestamp        math.HexOrDecimal64
-	ParentTimestamp  math.HexOrDecimal64
-	BaseFee          *math.HexOrDecimal256
 }
 
 type rejectedTx struct {
@@ -99,7 +89,7 @@ type rejectedTx struct {
 // Apply applies a set of transactions to a pre-state
 func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	txs types.Transactions, miningReward int64,
-	getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error)) (*state.StateDB, *ExecutionResult, error) {
+	getTracerFn func(txIndex int, txHash common.Hash) (tracer vm.Tracer, err error)) (*state.StateDB, *ExecutionResult, error) {
 
 	// Capture errors for BLOCKHASH operation, if we haven't been supplied the
 	// required blockhashes
@@ -141,11 +131,6 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	if pre.Env.BaseFee != nil {
 		vmContext.BaseFee = new(big.Int).Set(pre.Env.BaseFee)
 	}
-	// If random is defined, add it to the vmContext.
-	if pre.Env.Random != nil {
-		rnd := common.BigToHash(pre.Env.Random)
-		vmContext.Random = &rnd
-	}
 	// If DAO is supported/enabled, we need to handle it here. In geth 'proper', it's
 	// done in StateProcessor.Process(block, ...), right before transactions are applied.
 	if chainConfig.DAOForkSupport &&
@@ -262,8 +247,6 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 		LogsHash:    rlpHash(statedb.Logs()),
 		Receipts:    receipts,
 		Rejected:    rejectedTxs,
-		Difficulty:  (*math.HexOrDecimal256)(vmContext.Difficulty),
-		GasUsed:     (math.HexOrDecimal64)(gasUsed),
 	}
 	return statedb, execRs, nil
 }
@@ -291,23 +274,3 @@ func rlpHash(x interface{}) (h common.Hash) {
 	hw.Sum(h[:0])
 	return h
 }
-
-// calcDifficulty is based on ethash.CalcDifficulty. This method is used in case
-// the caller does not provide an explicit difficulty, but instead provides only
-// parent timestamp + difficulty.
-// Note: this method only works for ethash engine.
-func calcDifficulty(config *params.ChainConfig, number, currentTime, parentTime uint64,
-	parentDifficulty *big.Int, parentUncleHash common.Hash) *big.Int {
-	uncleHash := parentUncleHash
-	if uncleHash == (common.Hash{}) {
-		uncleHash = types.EmptyUncleHash
-	}
-	parent := &types.Header{
-		ParentHash: common.Hash{},
-		UncleHash:  uncleHash,
-		Difficulty: parentDifficulty,
-		Number:     new(big.Int).SetUint64(number - 1),
-		Time:       parentTime,
-	}
-	return ethash.CalcDifficulty(config, currentTime, parent)
-}

cmd/evm/internal/t8ntool/flags.go

@@ -30,25 +30,17 @@ var (
 		Name:  "trace",
 		Usage: "Output full trace logs to files <txhash>.jsonl",
 	}
-	TraceDisableMemoryFlag = cli.BoolTFlag{
+	TraceDisableMemoryFlag = cli.BoolFlag{
 		Name:  "trace.nomemory",
-		Usage: "Disable full memory dump in traces (deprecated)",
+		Usage: "Disable full memory dump in traces",
-	}
-	TraceEnableMemoryFlag = cli.BoolFlag{
-		Name:  "trace.memory",
-		Usage: "Enable full memory dump in traces",
 	}
 	TraceDisableStackFlag = cli.BoolFlag{
 		Name:  "trace.nostack",
 		Usage: "Disable stack output in traces",
 	}
-	TraceDisableReturnDataFlag = cli.BoolTFlag{
+	TraceDisableReturnDataFlag = cli.BoolFlag{
 		Name:  "trace.noreturndata",
-		Usage: "Disable return data output in traces (deprecated)",
+		Usage: "Disable return data output in traces",
-	}
-	TraceEnableReturnDataFlag = cli.BoolFlag{
-		Name:  "trace.returndata",
-		Usage: "Enable return data output in traces",
 	}
 	OutputBasedir = cli.StringFlag{
 		Name:  "output.basedir",
@@ -76,14 +68,6 @@ var (
 			"\t<file> - into the file <file> ",
 		Value: "result.json",
 	}
-	OutputBlockFlag = cli.StringFlag{
-		Name: "output.block",
-		Usage: "Determines where to put the `block` after building.\n" +
-			"\t`stdout` - into the stdout output\n" +
-			"\t`stderr` - into the stderr output\n" +
-			"\t<file> - into the file <file> ",
-		Value: "block.json",
-	}
 	InputAllocFlag = cli.StringFlag{
 		Name:  "input.alloc",
 		Usage: "`stdin` or file name of where to find the prestate alloc to use.",
@@ -97,41 +81,10 @@ var (
 	InputTxsFlag = cli.StringFlag{
 		Name: "input.txs",
 		Usage: "`stdin` or file name of where to find the transactions to apply. " +
-			"If the file extension is '.rlp', then the data is interpreted as an RLP list of signed transactions." +
+			"If the file prefix is '.rlp', then the data is interpreted as an RLP list of signed transactions." +
 			"The '.rlp' format is identical to the output.body format.",
 		Value: "txs.json",
 	}
-	InputHeaderFlag = cli.StringFlag{
-		Name:  "input.header",
-		Usage: "`stdin` or file name of where to find the block header to use.",
-		Value: "header.json",
-	}
-	InputOmmersFlag = cli.StringFlag{
-		Name:  "input.ommers",
-		Usage: "`stdin` or file name of where to find the list of ommer header RLPs to use.",
-	}
-	InputTxsRlpFlag = cli.StringFlag{
-		Name:  "input.txs",
-		Usage: "`stdin` or file name of where to find the transactions list in RLP form.",
-		Value: "txs.rlp",
-	}
-	SealCliqueFlag = cli.StringFlag{
-		Name:  "seal.clique",
-		Usage: "Seal block with Clique. `stdin` or file name of where to find the Clique sealing data.",
-	}
-	SealEthashFlag = cli.BoolFlag{
-		Name:  "seal.ethash",
-		Usage: "Seal block with ethash.",
-	}
-	SealEthashDirFlag = cli.StringFlag{
-		Name:  "seal.ethash.dir",
-		Usage: "Path to ethash DAG. If none exists, a new DAG will be generated.",
-	}
-	SealEthashModeFlag = cli.StringFlag{
-		Name:  "seal.ethash.mode",
-		Usage: "Defines the type and amount of PoW verification an ethash engine makes.",
-		Value: "normal",
-	}
 	RewardFlag = cli.Int64Flag{
 		Name:  "state.reward",
 		Usage: "Mining reward. Set to -1 to disable",

cmd/evm/internal/t8ntool/gen_header.go

@@ -1,135 +0,0 @@
-// Code generated by github.com/fjl/gencodec. DO NOT EDIT.
-
-package t8ntool
-
-import (
-	"encoding/json"
-	"errors"
-	"math/big"
-
-	"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/core/types"
-)
-
-var _ = (*headerMarshaling)(nil)
-
-// MarshalJSON marshals as JSON.
-func (h header) MarshalJSON() ([]byte, error) {
-	type header struct {
-		ParentHash  common.Hash           `json:"parentHash"`
-		OmmerHash   *common.Hash          `json:"sha3Uncles"`
-		Coinbase    *common.Address       `json:"miner"`
-		Root        common.Hash           `json:"stateRoot"        gencodec:"required"`
-		TxHash      *common.Hash          `json:"transactionsRoot"`
-		ReceiptHash *common.Hash          `json:"receiptsRoot"`
-		Bloom       types.Bloom           `json:"logsBloom"`
-		Difficulty  *math.HexOrDecimal256 `json:"difficulty"`
-		Number      *math.HexOrDecimal256 `json:"number"           gencodec:"required"`
-		GasLimit    math.HexOrDecimal64   `json:"gasLimit"         gencodec:"required"`
-		GasUsed     math.HexOrDecimal64   `json:"gasUsed"`
-		Time        math.HexOrDecimal64   `json:"timestamp"        gencodec:"required"`
-		Extra       hexutil.Bytes         `json:"extraData"`
-		MixDigest   common.Hash           `json:"mixHash"`
-		Nonce       *types.BlockNonce     `json:"nonce"`
-		BaseFee     *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"`
-	}
-	var enc header
-	enc.ParentHash = h.ParentHash
-	enc.OmmerHash = h.OmmerHash
-	enc.Coinbase = h.Coinbase
-	enc.Root = h.Root
-	enc.TxHash = h.TxHash
-	enc.ReceiptHash = h.ReceiptHash
-	enc.Bloom = h.Bloom
-	enc.Difficulty = (*math.HexOrDecimal256)(h.Difficulty)
-	enc.Number = (*math.HexOrDecimal256)(h.Number)
-	enc.GasLimit = math.HexOrDecimal64(h.GasLimit)
-	enc.GasUsed = math.HexOrDecimal64(h.GasUsed)
-	enc.Time = math.HexOrDecimal64(h.Time)
-	enc.Extra = h.Extra
-	enc.MixDigest = h.MixDigest
-	enc.Nonce = h.Nonce
-	enc.BaseFee = (*math.HexOrDecimal256)(h.BaseFee)
-	return json.Marshal(&enc)
-}
-
-// UnmarshalJSON unmarshals from JSON.
-func (h *header) UnmarshalJSON(input []byte) error {
-	type header struct {
-		ParentHash  *common.Hash          `json:"parentHash"`
-		OmmerHash   *common.Hash          `json:"sha3Uncles"`
-		Coinbase    *common.Address       `json:"miner"`
-		Root        *common.Hash          `json:"stateRoot"        gencodec:"required"`
-		TxHash      *common.Hash          `json:"transactionsRoot"`
-		ReceiptHash *common.Hash          `json:"receiptsRoot"`
-		Bloom       *types.Bloom          `json:"logsBloom"`
-		Difficulty  *math.HexOrDecimal256 `json:"difficulty"`
-		Number      *math.HexOrDecimal256 `json:"number"           gencodec:"required"`
-		GasLimit    *math.HexOrDecimal64  `json:"gasLimit"         gencodec:"required"`
-		GasUsed     *math.HexOrDecimal64  `json:"gasUsed"`
-		Time        *math.HexOrDecimal64  `json:"timestamp"        gencodec:"required"`
-		Extra       *hexutil.Bytes        `json:"extraData"`
-		MixDigest   *common.Hash          `json:"mixHash"`
-		Nonce       *types.BlockNonce     `json:"nonce"`
-		BaseFee     *math.HexOrDecimal256 `json:"baseFeePerGas" rlp:"optional"`
-	}
-	var dec header
-	if err := json.Unmarshal(input, &dec); err != nil {
-		return err
-	}
-	if dec.ParentHash != nil {
-		h.ParentHash = *dec.ParentHash
-	}
-	if dec.OmmerHash != nil {
-		h.OmmerHash = dec.OmmerHash
-	}
-	if dec.Coinbase != nil {
-		h.Coinbase = dec.Coinbase
-	}
-	if dec.Root == nil {
-		return errors.New("missing required field 'stateRoot' for header")
-	}
-	h.Root = *dec.Root
-	if dec.TxHash != nil {
-		h.TxHash = dec.TxHash
-	}
-	if dec.ReceiptHash != nil {
-		h.ReceiptHash = dec.ReceiptHash
-	}
-	if dec.Bloom != nil {
-		h.Bloom = *dec.Bloom
-	}
-	if dec.Difficulty != nil {
-		h.Difficulty = (*big.Int)(dec.Difficulty)
-	}
-	if dec.Number == nil {
-		return errors.New("missing required field 'number' for header")
-	}
-	h.Number = (*big.Int)(dec.Number)
-	if dec.GasLimit == nil {
-		return errors.New("missing required field 'gasLimit' for header")
-	}
-	h.GasLimit = uint64(*dec.GasLimit)
-	if dec.GasUsed != nil {
-		h.GasUsed = uint64(*dec.GasUsed)
-	}
-	if dec.Time == nil {
-		return errors.New("missing required field 'timestamp' for header")
-	}
-	h.Time = uint64(*dec.Time)
-	if dec.Extra != nil {
-		h.Extra = *dec.Extra
-	}
-	if dec.MixDigest != nil {
-		h.MixDigest = *dec.MixDigest
-	}
-	if dec.Nonce != nil {
-		h.Nonce = dec.Nonce
-	}
-	if dec.BaseFee != nil {
-		h.BaseFee = (*big.Int)(dec.BaseFee)
-	}
-	return nil
-}

cmd/evm/internal/t8ntool/gen_stenv.go

@@ -16,50 +16,38 @@ var _ = (*stEnvMarshaling)(nil)
 // MarshalJSON marshals as JSON.
 func (s stEnv) MarshalJSON() ([]byte, error) {
 	type stEnv struct {
-		Coinbase         common.UnprefixedAddress            `json:"currentCoinbase"   gencodec:"required"`
+		Coinbase    common.UnprefixedAddress            `json:"currentCoinbase"   gencodec:"required"`
-		Difficulty       *math.HexOrDecimal256               `json:"currentDifficulty"`
+		Difficulty  *math.HexOrDecimal256               `json:"currentDifficulty" gencodec:"required"`
-		Random           *math.HexOrDecimal256               `json:"currentRandom"`
+		GasLimit    math.HexOrDecimal64                 `json:"currentGasLimit"   gencodec:"required"`
-		ParentDifficulty *math.HexOrDecimal256               `json:"parentDifficulty"`
+		Number      math.HexOrDecimal64                 `json:"currentNumber"     gencodec:"required"`
-		GasLimit         math.HexOrDecimal64                 `json:"currentGasLimit"   gencodec:"required"`
+		Timestamp   math.HexOrDecimal64                 `json:"currentTimestamp"  gencodec:"required"`
-		Number           math.HexOrDecimal64                 `json:"currentNumber"     gencodec:"required"`
+		BlockHashes map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Timestamp        math.HexOrDecimal64                 `json:"currentTimestamp"  gencodec:"required"`
+		Ommers      []ommer                             `json:"ommers,omitempty"`
-		ParentTimestamp  math.HexOrDecimal64                 `json:"parentTimestamp,omitempty"`
+		BaseFee     *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Ommers           []ommer                             `json:"ommers,omitempty"`
-		BaseFee          *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		ParentUncleHash  common.Hash                         `json:"parentUncleHash"`
 	}
 	var enc stEnv
 	enc.Coinbase = common.UnprefixedAddress(s.Coinbase)
 	enc.Difficulty = (*math.HexOrDecimal256)(s.Difficulty)
-	enc.Random = (*math.HexOrDecimal256)(s.Random)
-	enc.ParentDifficulty = (*math.HexOrDecimal256)(s.ParentDifficulty)
 	enc.GasLimit = math.HexOrDecimal64(s.GasLimit)
 	enc.Number = math.HexOrDecimal64(s.Number)
 	enc.Timestamp = math.HexOrDecimal64(s.Timestamp)
-	enc.ParentTimestamp = math.HexOrDecimal64(s.ParentTimestamp)
 	enc.BlockHashes = s.BlockHashes
 	enc.Ommers = s.Ommers
 	enc.BaseFee = (*math.HexOrDecimal256)(s.BaseFee)
-	enc.ParentUncleHash = s.ParentUncleHash
 	return json.Marshal(&enc)
 }
 
 // UnmarshalJSON unmarshals from JSON.
 func (s *stEnv) UnmarshalJSON(input []byte) error {
 	type stEnv struct {
-		Coinbase         *common.UnprefixedAddress           `json:"currentCoinbase"   gencodec:"required"`
+		Coinbase    *common.UnprefixedAddress           `json:"currentCoinbase"   gencodec:"required"`
-		Difficulty       *math.HexOrDecimal256               `json:"currentDifficulty"`
+		Difficulty  *math.HexOrDecimal256               `json:"currentDifficulty" gencodec:"required"`
-		Random           *math.HexOrDecimal256               `json:"currentRandom"`
+		GasLimit    *math.HexOrDecimal64                `json:"currentGasLimit"   gencodec:"required"`
-		ParentDifficulty *math.HexOrDecimal256               `json:"parentDifficulty"`
+		Number      *math.HexOrDecimal64                `json:"currentNumber"     gencodec:"required"`
-		GasLimit         *math.HexOrDecimal64                `json:"currentGasLimit"   gencodec:"required"`
+		Timestamp   *math.HexOrDecimal64                `json:"currentTimestamp"  gencodec:"required"`
-		Number           *math.HexOrDecimal64                `json:"currentNumber"     gencodec:"required"`
+		BlockHashes map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Timestamp        *math.HexOrDecimal64                `json:"currentTimestamp"  gencodec:"required"`
+		Ommers      []ommer                             `json:"ommers,omitempty"`
-		ParentTimestamp  *math.HexOrDecimal64                `json:"parentTimestamp,omitempty"`
+		BaseFee     *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		BlockHashes      map[math.HexOrDecimal64]common.Hash `json:"blockHashes,omitempty"`
-		Ommers           []ommer                             `json:"ommers,omitempty"`
-		BaseFee          *math.HexOrDecimal256               `json:"currentBaseFee,omitempty"`
-		ParentUncleHash  *common.Hash                        `json:"parentUncleHash"`
 	}
 	var dec stEnv
 	if err := json.Unmarshal(input, &dec); err != nil {
@@ -69,15 +57,10 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 		return errors.New("missing required field 'currentCoinbase' for stEnv")
 	}
 	s.Coinbase = common.Address(*dec.Coinbase)
-	if dec.Difficulty != nil {
+	if dec.Difficulty == nil {
-		s.Difficulty = (*big.Int)(dec.Difficulty)
+		return errors.New("missing required field 'currentDifficulty' for stEnv")
-	}
-	if dec.Random != nil {
-		s.Random = (*big.Int)(dec.Random)
-	}
-	if dec.ParentDifficulty != nil {
-		s.ParentDifficulty = (*big.Int)(dec.ParentDifficulty)
 	}
+	s.Difficulty = (*big.Int)(dec.Difficulty)
 	if dec.GasLimit == nil {
 		return errors.New("missing required field 'currentGasLimit' for stEnv")
 	}
@@ -90,9 +73,6 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 		return errors.New("missing required field 'currentTimestamp' for stEnv")
 	}
 	s.Timestamp = uint64(*dec.Timestamp)
-	if dec.ParentTimestamp != nil {
-		s.ParentTimestamp = uint64(*dec.ParentTimestamp)
-	}
 	if dec.BlockHashes != nil {
 		s.BlockHashes = dec.BlockHashes
 	}
@@ -102,8 +82,5 @@ func (s *stEnv) UnmarshalJSON(input []byte) error {
 	if dec.BaseFee != nil {
 		s.BaseFee = (*big.Int)(dec.BaseFee)
 	}
-	if dec.ParentUncleHash != nil {
-		s.ParentUncleHash = *dec.ParentUncleHash
-	}
 	return nil
 }

cmd/evm/internal/t8ntool/transaction.go

@@ -1,179 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum 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.
-//
-// go-ethereum 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 go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package t8ntool
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"math/big"
-	"os"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/ethereum/go-ethereum/params"
-	"github.com/ethereum/go-ethereum/rlp"
-	"github.com/ethereum/go-ethereum/tests"
-	"gopkg.in/urfave/cli.v1"
-)
-
-type result struct {
-	Error        error
-	Address      common.Address
-	Hash         common.Hash
-	IntrinsicGas uint64
-}
-
-// MarshalJSON marshals as JSON with a hash.
-func (r *result) MarshalJSON() ([]byte, error) {
-	type xx struct {
-		Error        string          `json:"error,omitempty"`
-		Address      *common.Address `json:"address,omitempty"`
-		Hash         *common.Hash    `json:"hash,omitempty"`
-		IntrinsicGas hexutil.Uint64  `json:"intrinsicGas,omitempty"`
-	}
-	var out xx
-	if r.Error != nil {
-		out.Error = r.Error.Error()
-	}
-	if r.Address != (common.Address{}) {
-		out.Address = &r.Address
-	}
-	if r.Hash != (common.Hash{}) {
-		out.Hash = &r.Hash
-	}
-	out.IntrinsicGas = hexutil.Uint64(r.IntrinsicGas)
-	return json.Marshal(out)
-}
-
-func Transaction(ctx *cli.Context) error {
-	// Configure the go-ethereum logger
-	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
-	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
-	log.Root().SetHandler(glogger)
-
-	var (
-		err error
-	)
-	// We need to load the transactions. May be either in stdin input or in files.
-	// Check if anything needs to be read from stdin
-	var (
-		txStr       = ctx.String(InputTxsFlag.Name)
-		inputData   = &input{}
-		chainConfig *params.ChainConfig
-	)
-	// Construct the chainconfig
-	if cConf, _, err := tests.GetChainConfig(ctx.String(ForknameFlag.Name)); err != nil {
-		return NewError(ErrorConfig, fmt.Errorf("failed constructing chain configuration: %v", err))
-	} else {
-		chainConfig = cConf
-	}
-	// Set the chain id
-	chainConfig.ChainID = big.NewInt(ctx.Int64(ChainIDFlag.Name))
-	var body hexutil.Bytes
-	if txStr == stdinSelector {
-		decoder := json.NewDecoder(os.Stdin)
-		if err := decoder.Decode(inputData); err != nil {
-			return NewError(ErrorJson, fmt.Errorf("failed unmarshaling stdin: %v", err))
-		}
-		// Decode the body of already signed transactions
-		body = common.FromHex(inputData.TxRlp)
-	} else {
-		// Read input from file
-		inFile, err := os.Open(txStr)
-		if err != nil {
-			return NewError(ErrorIO, fmt.Errorf("failed reading txs file: %v", err))
-		}
-		defer inFile.Close()
-		decoder := json.NewDecoder(inFile)
-		if strings.HasSuffix(txStr, ".rlp") {
-			if err := decoder.Decode(&body); err != nil {
-				return err
-			}
-		} else {
-			return NewError(ErrorIO, errors.New("only rlp supported"))
-		}
-	}
-	signer := types.MakeSigner(chainConfig, new(big.Int))
-	// We now have the transactions in 'body', which is supposed to be an
-	// rlp list of transactions
-	it, err := rlp.NewListIterator([]byte(body))
-	if err != nil {
-		return err
-	}
-	var results []result
-	for it.Next() {
-		if err := it.Err(); err != nil {
-			return NewError(ErrorIO, err)
-		}
-		var tx types.Transaction
-		err := rlp.DecodeBytes(it.Value(), &tx)
-		if err != nil {
-			results = append(results, result{Error: err})
-			continue
-		}
-		r := result{Hash: tx.Hash()}
-		if sender, err := types.Sender(signer, &tx); err != nil {
-			r.Error = err
-			results = append(results, r)
-			continue
-		} else {
-			r.Address = sender
-		}
-		// Check intrinsic gas
-		if gas, err := core.IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil,
-			chainConfig.IsHomestead(new(big.Int)), chainConfig.IsIstanbul(new(big.Int))); err != nil {
-			r.Error = err
-			results = append(results, r)
-			continue
-		} else {
-			r.IntrinsicGas = gas
-			if tx.Gas() < gas {
-				r.Error = fmt.Errorf("%w: have %d, want %d", core.ErrIntrinsicGas, tx.Gas(), gas)
-				results = append(results, r)
-				continue
-			}
-		}
-		// Validate <256bit fields
-		switch {
-		case tx.Nonce()+1 < tx.Nonce():
-			r.Error = errors.New("nonce exceeds 2^64-1")
-		case tx.Value().BitLen() > 256:
-			r.Error = errors.New("value exceeds 256 bits")
-		case tx.GasPrice().BitLen() > 256:
-			r.Error = errors.New("gasPrice exceeds 256 bits")
-		case tx.GasTipCap().BitLen() > 256:
-			r.Error = errors.New("maxPriorityFeePerGas exceeds 256 bits")
-		case tx.GasFeeCap().BitLen() > 256:
-			r.Error = errors.New("maxFeePerGas exceeds 256 bits")
-		case tx.GasFeeCap().Cmp(tx.GasTipCap()) < 0:
-			r.Error = errors.New("maxFeePerGas < maxPriorityFeePerGas")
-		case new(big.Int).Mul(tx.GasPrice(), new(big.Int).SetUint64(tx.Gas())).BitLen() > 256:
-			r.Error = errors.New("gas * gasPrice exceeds 256 bits")
-		case new(big.Int).Mul(tx.GasFeeCap(), new(big.Int).SetUint64(tx.Gas())).BitLen() > 256:
-			r.Error = errors.New("gas * maxFeePerGas exceeds 256 bits")
-		}
-		results = append(results, r)
-	}
-	out, err := json.MarshalIndent(results, "", "  ")
-	fmt.Println(string(out))
-	return err
-}

cmd/evm/internal/t8ntool/transition.go

@@ -34,7 +34,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rlp"
@@ -44,12 +43,11 @@ import (
 
 const (
 	ErrorEVM              = 2
-	ErrorConfig           = 3
+	ErrorVMConfig         = 3
 	ErrorMissingBlockhash = 4
 
 	ErrorJson = 10
 	ErrorIO   = 11
-	ErrorRlp  = 12
 
 	stdinSelector = "stdin"
 )
@@ -67,15 +65,10 @@ func (n *NumberedError) Error() string {
 	return fmt.Sprintf("ERROR(%d): %v", n.errorCode, n.err.Error())
 }
 
-func (n *NumberedError) ExitCode() int {
+func (n *NumberedError) Code() int {
 	return n.errorCode
 }
 
-// compile-time conformance test
-var (
-	_ cli.ExitCoder = (*NumberedError)(nil)
-)
-
 type input struct {
 	Alloc core.GenesisAlloc `json:"alloc,omitempty"`
 	Env   *stEnv            `json:"env,omitempty"`
@@ -83,41 +76,36 @@ type input struct {
 	TxRlp string            `json:"txsRlp,omitempty"`
 }
 
-func Transition(ctx *cli.Context) error {
+func Main(ctx *cli.Context) error {
 	// Configure the go-ethereum logger
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
 	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
 
 	var (
-		err    error
+		err     error
-		tracer vm.EVMLogger
+		tracer  vm.Tracer
+		baseDir = ""
 	)
-	var getTracer func(txIndex int, txHash common.Hash) (vm.EVMLogger, error)
+	var getTracer func(txIndex int, txHash common.Hash) (vm.Tracer, error)
 
-	baseDir, err := createBasedir(ctx)
+	// If user specified a basedir, make sure it exists
-	if err != nil {
+	if ctx.IsSet(OutputBasedir.Name) {
-		return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err))
+		if base := ctx.String(OutputBasedir.Name); len(base) > 0 {
+			err := os.MkdirAll(base, 0755) // //rw-r--r--
+			if err != nil {
+				return NewError(ErrorIO, fmt.Errorf("failed creating output basedir: %v", err))
+			}
+			baseDir = base
+		}
 	}
 	if ctx.Bool(TraceFlag.Name) {
-		if ctx.IsSet(TraceDisableMemoryFlag.Name) && ctx.IsSet(TraceEnableMemoryFlag.Name) {
-			return NewError(ErrorConfig, fmt.Errorf("can't use both flags --%s and --%s", TraceDisableMemoryFlag.Name, TraceEnableMemoryFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableReturnDataFlag.Name) && ctx.IsSet(TraceEnableReturnDataFlag.Name) {
-			return NewError(ErrorConfig, fmt.Errorf("can't use both flags --%s and --%s", TraceDisableReturnDataFlag.Name, TraceEnableReturnDataFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableMemoryFlag.Name) {
-			log.Warn(fmt.Sprintf("--%s has been deprecated in favour of --%s", TraceDisableMemoryFlag.Name, TraceEnableMemoryFlag.Name))
-		}
-		if ctx.IsSet(TraceDisableReturnDataFlag.Name) {
-			log.Warn(fmt.Sprintf("--%s has been deprecated in favour of --%s", TraceDisableReturnDataFlag.Name, TraceEnableReturnDataFlag.Name))
-		}
 		// Configure the EVM logger
-		logConfig := &logger.Config{
+		logConfig := &vm.LogConfig{
-			DisableStack:     ctx.Bool(TraceDisableStackFlag.Name),
+			DisableStack:      ctx.Bool(TraceDisableStackFlag.Name),
-			EnableMemory:     !ctx.Bool(TraceDisableMemoryFlag.Name) || ctx.Bool(TraceEnableMemoryFlag.Name),
+			DisableMemory:     ctx.Bool(TraceDisableMemoryFlag.Name),
-			EnableReturnData: !ctx.Bool(TraceDisableReturnDataFlag.Name) || ctx.Bool(TraceEnableReturnDataFlag.Name),
+			DisableReturnData: ctx.Bool(TraceDisableReturnDataFlag.Name),
-			Debug:            true,
+			Debug:             true,
 		}
 		var prevFile *os.File
 		// This one closes the last file
@@ -126,7 +114,7 @@ func Transition(ctx *cli.Context) error {
 				prevFile.Close()
 			}
 		}()
-		getTracer = func(txIndex int, txHash common.Hash) (vm.EVMLogger, error) {
+		getTracer = func(txIndex int, txHash common.Hash) (vm.Tracer, error) {
 			if prevFile != nil {
 				prevFile.Close()
 			}
@@ -135,10 +123,10 @@ func Transition(ctx *cli.Context) error {
 				return nil, NewError(ErrorIO, fmt.Errorf("failed creating trace-file: %v", err))
 			}
 			prevFile = traceFile
-			return logger.NewJSONLogger(logConfig, traceFile), nil
+			return vm.NewJSONLogger(logConfig, traceFile), nil
 		}
 	} else {
-		getTracer = func(txIndex int, txHash common.Hash) (tracer vm.EVMLogger, err error) {
+		getTracer = func(txIndex int, txHash common.Hash) (tracer vm.Tracer, err error) {
 			return nil, nil
 		}
 	}
@@ -162,17 +150,29 @@ func Transition(ctx *cli.Context) error {
 		}
 	}
 	if allocStr != stdinSelector {
-		if err := readFile(allocStr, "alloc", &inputData.Alloc); err != nil {
+		inFile, err := os.Open(allocStr)
-			return err
+		if err != nil {
+			return NewError(ErrorIO, fmt.Errorf("failed reading alloc file: %v", err))
+		}
+		defer inFile.Close()
+		decoder := json.NewDecoder(inFile)
+		if err := decoder.Decode(&inputData.Alloc); err != nil {
+			return NewError(ErrorJson, fmt.Errorf("failed unmarshaling alloc-file: %v", err))
 		}
 	}
 	prestate.Pre = inputData.Alloc
 
 	// Set the block environment
 	if envStr != stdinSelector {
+		inFile, err := os.Open(envStr)
+		if err != nil {
+			return NewError(ErrorIO, fmt.Errorf("failed reading env file: %v", err))
+		}
+		defer inFile.Close()
+		decoder := json.NewDecoder(inFile)
 		var env stEnv
-		if err := readFile(envStr, "env", &env); err != nil {
+		if err := decoder.Decode(&env); err != nil {
-			return err
+			return NewError(ErrorJson, fmt.Errorf("failed unmarshaling env-file: %v", err))
 		}
 		inputData.Env = &env
 	}
@@ -185,7 +185,7 @@ func Transition(ctx *cli.Context) error {
 	// Construct the chainconfig
 	var chainConfig *params.ChainConfig
 	if cConf, extraEips, err := tests.GetChainConfig(ctx.String(ForknameFlag.Name)); err != nil {
-		return NewError(ErrorConfig, fmt.Errorf("failed constructing chain configuration: %v", err))
+		return NewError(ErrorVMConfig, fmt.Errorf("failed constructing chain configuration: %v", err))
 	} else {
 		chainConfig = cConf
 		vmConfig.ExtraEips = extraEips
@@ -249,27 +249,9 @@ func Transition(ctx *cli.Context) error {
 	// Sanity check, to not `panic` in state_transition
 	if chainConfig.IsLondon(big.NewInt(int64(prestate.Env.Number))) {
 		if prestate.Env.BaseFee == nil {
-			return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
+			return NewError(ErrorVMConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
 		}
 	}
-	// Sanity check, to not `panic` in state_transition
-	if prestate.Env.Random != nil && !chainConfig.IsLondon(big.NewInt(int64(prestate.Env.Number))) {
-		return NewError(ErrorConfig, errors.New("can only apply RANDOM on top of London chainrules"))
-	}
-	if env := prestate.Env; env.Difficulty == nil {
-		// If difficulty was not provided by caller, we need to calculate it.
-		switch {
-		case env.ParentDifficulty == nil:
-			return NewError(ErrorConfig, errors.New("currentDifficulty was not provided, and cannot be calculated due to missing parentDifficulty"))
-		case env.Number == 0:
-			return NewError(ErrorConfig, errors.New("currentDifficulty needs to be provided for block number 0"))
-		case env.Timestamp <= env.ParentTimestamp:
-			return NewError(ErrorConfig, fmt.Errorf("currentDifficulty cannot be calculated -- currentTime (%d) needs to be after parent time (%d)",
-				env.Timestamp, env.ParentTimestamp))
-		}
-		prestate.Env.Difficulty = calcDifficulty(chainConfig, env.Number, env.Timestamp,
-			env.ParentTimestamp, env.ParentDifficulty, env.ParentUncleHash)
-	}
 	// Run the test and aggregate the result
 	s, result, err := prestate.Apply(vmConfig, chainConfig, txs, ctx.Int64(RewardFlag.Name), getTracer)
 	if err != nil {
@@ -285,34 +267,27 @@ func Transition(ctx *cli.Context) error {
 // txWithKey is a helper-struct, to allow us to use the types.Transaction along with
 // a `secretKey`-field, for input
 type txWithKey struct {
-	key       *ecdsa.PrivateKey
+	key *ecdsa.PrivateKey
-	tx        *types.Transaction
+	tx  *types.Transaction
-	protected bool
 }
 
 func (t *txWithKey) UnmarshalJSON(input []byte) error {
-	// Read the metadata, if present
+	// Read the secretKey, if present
-	type txMetadata struct {
+	type sKey struct {
-		Key       *common.Hash `json:"secretKey"`
+		Key *common.Hash `json:"secretKey"`
-		Protected *bool        `json:"protected"`
 	}
-	var data txMetadata
+	var key sKey
-	if err := json.Unmarshal(input, &data); err != nil {
+	if err := json.Unmarshal(input, &key); err != nil {
 		return err
 	}
-	if data.Key != nil {
+	if key.Key != nil {
-		k := data.Key.Hex()[2:]
+		k := key.Key.Hex()[2:]
 		if ecdsaKey, err := crypto.HexToECDSA(k); err != nil {
 			return err
 		} else {
 			t.key = ecdsaKey
 		}
 	}
-	if data.Protected != nil {
-		t.protected = *data.Protected
-	} else {
-		t.protected = true
-	}
 	// Now, read the transaction itself
 	var tx types.Transaction
 	if err := json.Unmarshal(input, &tx); err != nil {
@@ -341,15 +316,7 @@ func signUnsignedTransactions(txs []*txWithKey, signer types.Signer) (types.Tran
 		v, r, s := tx.RawSignatureValues()
 		if key != nil && v.BitLen()+r.BitLen()+s.BitLen() == 0 {
 			// This transaction needs to be signed
-			var (
+			signed, err := types.SignTx(tx, signer, key)
-				signed *types.Transaction
-				err    error
-			)
-			if txWithKey.protected {
-				signed, err = types.SignTx(tx, signer, key)
-			} else {
-				signed, err = types.SignTx(tx, types.FrontierSigner{}, key)
-			}
 			if err != nil {
 				return nil, NewError(ErrorJson, fmt.Errorf("tx %d: failed to sign tx: %v", i, err))
 			}
@@ -428,20 +395,20 @@ func dispatchOutput(ctx *cli.Context, baseDir string, result *ExecutionResult, a
 		return err
 	}
 	if len(stdOutObject) > 0 {
-		b, err := json.MarshalIndent(stdOutObject, "", "  ")
+		b, err := json.MarshalIndent(stdOutObject, "", " ")
 		if err != nil {
 			return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err))
 		}
 		os.Stdout.Write(b)
-		os.Stdout.WriteString("\n")
+		os.Stdout.Write([]byte("\n"))
 	}
 	if len(stdErrObject) > 0 {
-		b, err := json.MarshalIndent(stdErrObject, "", "  ")
+		b, err := json.MarshalIndent(stdErrObject, "", " ")
 		if err != nil {
 			return NewError(ErrorJson, fmt.Errorf("failed marshalling output: %v", err))
 		}
 		os.Stderr.Write(b)
-		os.Stderr.WriteString("\n")
+		os.Stderr.Write([]byte("\n"))
 	}
 	return nil
 }

cmd/evm/internal/t8ntool/utils.go

@@ -1,54 +0,0 @@
-// Copyright 2021 The go-ethereum Authors
-// This file is part of go-ethereum.
-//
-// go-ethereum 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.
-//
-// go-ethereum 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 go-ethereum. If not, see <http://www.gnu.org/licenses/>.
-
-package t8ntool
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"gopkg.in/urfave/cli.v1"
-)
-
-// readFile reads the json-data in the provided path and marshals into dest.
-func readFile(path, desc string, dest interface{}) error {
-	inFile, err := os.Open(path)
-	if err != nil {
-		return NewError(ErrorIO, fmt.Errorf("failed reading %s file: %v", desc, err))
-	}
-	defer inFile.Close()
-	decoder := json.NewDecoder(inFile)
-	if err := decoder.Decode(dest); err != nil {
-		return NewError(ErrorJson, fmt.Errorf("failed unmarshaling %s file: %v", desc, err))
-	}
-	return nil
-}
-
-// createBasedir makes sure the basedir exists, if user specified one.
-func createBasedir(ctx *cli.Context) (string, error) {
-	baseDir := ""
-	if ctx.IsSet(OutputBasedir.Name) {
-		if base := ctx.String(OutputBasedir.Name); len(base) > 0 {
-			err := os.MkdirAll(base, 0755) // //rw-r--r--
-			if err != nil {
-				return "", err
-			}
-			baseDir = base
-		}
-	}
-	return baseDir, nil
-}

cmd/evm/main.go

@@ -113,7 +113,7 @@ var (
 		Name:  "receiver",
 		Usage: "The transaction receiver (execution context)",
 	}
-	DisableMemoryFlag = cli.BoolTFlag{
+	DisableMemoryFlag = cli.BoolFlag{
 		Name:  "nomemory",
 		Usage: "disable memory output",
 	}
@@ -125,9 +125,9 @@ var (
 		Name:  "nostorage",
 		Usage: "disable storage output",
 	}
-	DisableReturnDataFlag = cli.BoolTFlag{
+	DisableReturnDataFlag = cli.BoolFlag{
 		Name:  "noreturndata",
-		Usage: "enable return data output",
+		Usage: "disable return data output",
 	}
 )
 
@@ -135,14 +135,12 @@ var stateTransitionCommand = cli.Command{
 	Name:    "transition",
 	Aliases: []string{"t8n"},
 	Usage:   "executes a full state transition",
-	Action:  t8ntool.Transition,
+	Action:  t8ntool.Main,
 	Flags: []cli.Flag{
 		t8ntool.TraceFlag,
 		t8ntool.TraceDisableMemoryFlag,
-		t8ntool.TraceEnableMemoryFlag,
 		t8ntool.TraceDisableStackFlag,
 		t8ntool.TraceDisableReturnDataFlag,
-		t8ntool.TraceEnableReturnDataFlag,
 		t8ntool.OutputBasedir,
 		t8ntool.OutputAllocFlag,
 		t8ntool.OutputResultFlag,
@@ -156,37 +154,6 @@ var stateTransitionCommand = cli.Command{
 		t8ntool.VerbosityFlag,
 	},
 }
-var transactionCommand = cli.Command{
-	Name:    "transaction",
-	Aliases: []string{"t9n"},
-	Usage:   "performs transaction validation",
-	Action:  t8ntool.Transaction,
-	Flags: []cli.Flag{
-		t8ntool.InputTxsFlag,
-		t8ntool.ChainIDFlag,
-		t8ntool.ForknameFlag,
-		t8ntool.VerbosityFlag,
-	},
-}
-
-var blockBuilderCommand = cli.Command{
-	Name:    "block-builder",
-	Aliases: []string{"b11r"},
-	Usage:   "builds a block",
-	Action:  t8ntool.BuildBlock,
-	Flags: []cli.Flag{
-		t8ntool.OutputBasedir,
-		t8ntool.OutputBlockFlag,
-		t8ntool.InputHeaderFlag,
-		t8ntool.InputOmmersFlag,
-		t8ntool.InputTxsRlpFlag,
-		t8ntool.SealCliqueFlag,
-		t8ntool.SealEthashFlag,
-		t8ntool.SealEthashDirFlag,
-		t8ntool.SealEthashModeFlag,
-		t8ntool.VerbosityFlag,
-	},
-}
 
 func init() {
 	app.Flags = []cli.Flag{
@@ -220,8 +187,6 @@ func init() {
 		runCommand,
 		stateTestCommand,
 		stateTransitionCommand,
-		transactionCommand,
-		blockBuilderCommand,
 	}
 	cli.CommandHelpTemplate = flags.OriginCommandHelpTemplate
 }
@@ -230,7 +195,7 @@ func main() {
 	if err := app.Run(os.Args); err != nil {
 		code := 1
 		if ec, ok := err.(*t8ntool.NumberedError); ok {
-			code = ec.ExitCode()
+			code = ec.Code()
 		}
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(code)

cmd/evm/runner.go

@@ -36,7 +36,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/core/vm/runtime"
-	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"gopkg.in/urfave/cli.v1"
@@ -108,17 +107,17 @@ func runCmd(ctx *cli.Context) error {
 	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
 	glogger.Verbosity(log.Lvl(ctx.GlobalInt(VerbosityFlag.Name)))
 	log.Root().SetHandler(glogger)
-	logconfig := &logger.Config{
+	logconfig := &vm.LogConfig{
-		EnableMemory:     !ctx.GlobalBool(DisableMemoryFlag.Name),
+		DisableMemory:     ctx.GlobalBool(DisableMemoryFlag.Name),
-		DisableStack:     ctx.GlobalBool(DisableStackFlag.Name),
+		DisableStack:      ctx.GlobalBool(DisableStackFlag.Name),
-		DisableStorage:   ctx.GlobalBool(DisableStorageFlag.Name),
+		DisableStorage:    ctx.GlobalBool(DisableStorageFlag.Name),
-		EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
+		DisableReturnData: ctx.GlobalBool(DisableReturnDataFlag.Name),
-		Debug:            ctx.GlobalBool(DebugFlag.Name),
+		Debug:             ctx.GlobalBool(DebugFlag.Name),
 	}
 
 	var (
-		tracer        vm.EVMLogger
+		tracer        vm.Tracer
-		debugLogger   *logger.StructLogger
+		debugLogger   *vm.StructLogger
 		statedb       *state.StateDB
 		chainConfig   *params.ChainConfig
 		sender        = common.BytesToAddress([]byte("sender"))
@@ -126,12 +125,12 @@ func runCmd(ctx *cli.Context) error {
 		genesisConfig *core.Genesis
 	)
 	if ctx.GlobalBool(MachineFlag.Name) {
-		tracer = logger.NewJSONLogger(logconfig, os.Stdout)
+		tracer = vm.NewJSONLogger(logconfig, os.Stdout)
 	} else if ctx.GlobalBool(DebugFlag.Name) {
-		debugLogger = logger.NewStructLogger(logconfig)
+		debugLogger = vm.NewStructLogger(logconfig)
 		tracer = debugLogger
 	} else {
-		debugLogger = logger.NewStructLogger(logconfig)
+		debugLogger = vm.NewStructLogger(logconfig)
 	}
 	if ctx.GlobalString(GenesisFlag.Name) != "" {
 		gen := readGenesis(ctx.GlobalString(GenesisFlag.Name))
@@ -289,10 +288,10 @@ func runCmd(ctx *cli.Context) error {
 	if ctx.GlobalBool(DebugFlag.Name) {
 		if debugLogger != nil {
 			fmt.Fprintln(os.Stderr, "#### TRACE ####")
-			logger.WriteTrace(os.Stderr, debugLogger.StructLogs())
+			vm.WriteTrace(os.Stderr, debugLogger.StructLogs())
 		}
 		fmt.Fprintln(os.Stderr, "#### LOGS ####")
-		logger.WriteLogs(os.Stderr, statedb.Logs())
+		vm.WriteLogs(os.Stderr, statedb.Logs())
 	}
 
 	if bench || ctx.GlobalBool(StatDumpFlag.Name) {

cmd/evm/staterunner.go

@@ -25,7 +25,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/eth/tracers/logger"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/tests"
 
@@ -59,26 +58,26 @@ func stateTestCmd(ctx *cli.Context) error {
 	log.Root().SetHandler(glogger)
 
 	// Configure the EVM logger
-	config := &logger.Config{
+	config := &vm.LogConfig{
-		EnableMemory:     !ctx.GlobalBool(DisableMemoryFlag.Name),
+		DisableMemory:     ctx.GlobalBool(DisableMemoryFlag.Name),
-		DisableStack:     ctx.GlobalBool(DisableStackFlag.Name),
+		DisableStack:      ctx.GlobalBool(DisableStackFlag.Name),
-		DisableStorage:   ctx.GlobalBool(DisableStorageFlag.Name),
+		DisableStorage:    ctx.GlobalBool(DisableStorageFlag.Name),
-		EnableReturnData: !ctx.GlobalBool(DisableReturnDataFlag.Name),
+		DisableReturnData: ctx.GlobalBool(DisableReturnDataFlag.Name),
 	}
 	var (
-		tracer   vm.EVMLogger
+		tracer   vm.Tracer
-		debugger *logger.StructLogger
+		debugger *vm.StructLogger
 	)
 	switch {
 	case ctx.GlobalBool(MachineFlag.Name):
-		tracer = logger.NewJSONLogger(config, os.Stderr)
+		tracer = vm.NewJSONLogger(config, os.Stderr)
 
 	case ctx.GlobalBool(DebugFlag.Name):
-		debugger = logger.NewStructLogger(config)
+		debugger = vm.NewStructLogger(config)
 		tracer = debugger
 
 	default:
-		debugger = logger.NewStructLogger(config)
+		debugger = vm.NewStructLogger(config)
 	}
 	// Load the test content from the input file
 	src, err := ioutil.ReadFile(ctx.Args().First())
@@ -119,7 +118,7 @@ func stateTestCmd(ctx *cli.Context) error {
 			if ctx.GlobalBool(DebugFlag.Name) {
 				if debugger != nil {
 					fmt.Fprintln(os.Stderr, "#### TRACE ####")
-					logger.WriteTrace(os.Stderr, debugger.StructLogs())
+					vm.WriteTrace(os.Stderr, debugger.StructLogs())
 				}
 			}
 		}

cmd/evm/t8n_test.go

@@ -1,477 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/docker/docker/pkg/reexec"
-	"github.com/ethereum/go-ethereum/cmd/evm/internal/t8ntool"
-	"github.com/ethereum/go-ethereum/internal/cmdtest"
-)
-
-func TestMain(m *testing.M) {
-	// Run the app if we've been exec'd as "ethkey-test" in runEthkey.
-	reexec.Register("evm-test", func() {
-		if err := app.Run(os.Args); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Exit(0)
-	})
-	// check if we have been reexec'd
-	if reexec.Init() {
-		return
-	}
-	os.Exit(m.Run())
-}
-
-type testT8n struct {
-	*cmdtest.TestCmd
-}
-
-type t8nInput struct {
-	inAlloc  string
-	inTxs    string
-	inEnv    string
-	stFork   string
-	stReward string
-}
-
-func (args *t8nInput) get(base string) []string {
-	var out []string
-	if opt := args.inAlloc; opt != "" {
-		out = append(out, "--input.alloc")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.inTxs; opt != "" {
-		out = append(out, "--input.txs")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.inEnv; opt != "" {
-		out = append(out, "--input.env")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.stFork; opt != "" {
-		out = append(out, "--state.fork", opt)
-	}
-	if opt := args.stReward; opt != "" {
-		out = append(out, "--state.reward", opt)
-	}
-	return out
-}
-
-type t8nOutput struct {
-	alloc  bool
-	result bool
-	body   bool
-}
-
-func (args *t8nOutput) get() (out []string) {
-	if args.body {
-		out = append(out, "--output.body", "stdout")
-	} else {
-		out = append(out, "--output.body", "") // empty means ignore
-	}
-	if args.result {
-		out = append(out, "--output.result", "stdout")
-	} else {
-		out = append(out, "--output.result", "")
-	}
-	if args.alloc {
-		out = append(out, "--output.alloc", "stdout")
-	} else {
-		out = append(out, "--output.alloc", "")
-	}
-	return out
-}
-
-func TestT8n(t *testing.T) {
-	tt := new(testT8n)
-	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
-	for i, tc := range []struct {
-		base        string
-		input       t8nInput
-		output      t8nOutput
-		expExitCode int
-		expOut      string
-	}{
-		{ // Test exit (3) on bad config
-			base: "./testdata/1",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Frontier+1346", "",
-			},
-			output:      t8nOutput{alloc: true, result: true},
-			expExitCode: 3,
-		},
-		{
-			base: "./testdata/1",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Byzantium", "",
-			},
-			output: t8nOutput{alloc: true, result: true},
-			expOut: "exp.json",
-		},
-		{ // blockhash test
-			base: "./testdata/3",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Berlin", "",
-			},
-			output: t8nOutput{alloc: true, result: true},
-			expOut: "exp.json",
-		},
-		{ // missing blockhash test
-			base: "./testdata/4",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Berlin", "",
-			},
-			output:      t8nOutput{alloc: true, result: true},
-			expExitCode: 4,
-		},
-		{ // Uncle test
-			base: "./testdata/5",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Byzantium", "0x80",
-			},
-			output: t8nOutput{alloc: true, result: true},
-			expOut: "exp.json",
-		},
-		{ // Sign json transactions
-			base: "./testdata/13",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "London", "",
-			},
-			output: t8nOutput{body: true},
-			expOut: "exp.json",
-		},
-		{ // Already signed transactions
-			base: "./testdata/13",
-			input: t8nInput{
-				"alloc.json", "signed_txs.rlp", "env.json", "London", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp2.json",
-		},
-		{ // Difficulty calculation - no uncles
-			base: "./testdata/14",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "London", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp.json",
-		},
-		{ // Difficulty calculation - with uncles
-			base: "./testdata/14",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.uncles.json", "London", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp2.json",
-		},
-		{ // Difficulty calculation - with ommers + Berlin
-			base: "./testdata/14",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.uncles.json", "Berlin", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp_berlin.json",
-		},
-		{ // Difficulty calculation on arrow glacier
-			base: "./testdata/19",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "London", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp_london.json",
-		},
-		{ // Difficulty calculation on arrow glacier
-			base: "./testdata/19",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "ArrowGlacier", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp_arrowglacier.json",
-		},
-		{ // Sign unprotected (pre-EIP155) transaction
-			base: "./testdata/23",
-			input: t8nInput{
-				"alloc.json", "txs.json", "env.json", "Berlin", "",
-			},
-			output: t8nOutput{result: true},
-			expOut: "exp.json",
-		},
-	} {
-
-		args := []string{"t8n"}
-		args = append(args, tc.output.get()...)
-		args = append(args, tc.input.get(tc.base)...)
-		var qArgs []string // quoted args for debugging purposes
-		for _, arg := range args {
-			if len(arg) == 0 {
-				qArgs = append(qArgs, `""`)
-			} else {
-				qArgs = append(qArgs, arg)
-			}
-		}
-		tt.Logf("args: %v\n", strings.Join(qArgs, " "))
-		tt.Run("evm-test", args...)
-		// Compare the expected output, if provided
-		if tc.expOut != "" {
-			want, err := os.ReadFile(fmt.Sprintf("%v/%v", tc.base, tc.expOut))
-			if err != nil {
-				t.Fatalf("test %d: could not read expected output: %v", i, err)
-			}
-			have := tt.Output()
-			ok, err := cmpJson(have, want)
-			switch {
-			case err != nil:
-				t.Fatalf("test %d, json parsing failed: %v", i, err)
-			case !ok:
-				t.Fatalf("test %d: output wrong, have \n%v\nwant\n%v\n", i, string(have), string(want))
-			}
-		}
-		tt.WaitExit()
-		if have, want := tt.ExitStatus(), tc.expExitCode; have != want {
-			t.Fatalf("test %d: wrong exit code, have %d, want %d", i, have, want)
-		}
-	}
-}
-
-type t9nInput struct {
-	inTxs  string
-	stFork string
-}
-
-func (args *t9nInput) get(base string) []string {
-	var out []string
-	if opt := args.inTxs; opt != "" {
-		out = append(out, "--input.txs")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.stFork; opt != "" {
-		out = append(out, "--state.fork", opt)
-	}
-	return out
-}
-
-func TestT9n(t *testing.T) {
-	tt := new(testT8n)
-	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
-	for i, tc := range []struct {
-		base        string
-		input       t9nInput
-		expExitCode int
-		expOut      string
-	}{
-		{ // London txs on homestead
-			base: "./testdata/15",
-			input: t9nInput{
-				inTxs:  "signed_txs.rlp",
-				stFork: "Homestead",
-			},
-			expOut: "exp.json",
-		},
-		{ // London txs on London
-			base: "./testdata/15",
-			input: t9nInput{
-				inTxs:  "signed_txs.rlp",
-				stFork: "London",
-			},
-			expOut: "exp2.json",
-		},
-		{ // An RLP list (a blockheader really)
-			base: "./testdata/15",
-			input: t9nInput{
-				inTxs:  "blockheader.rlp",
-				stFork: "London",
-			},
-			expOut: "exp3.json",
-		},
-		{ // Transactions with too low gas
-			base: "./testdata/16",
-			input: t9nInput{
-				inTxs:  "signed_txs.rlp",
-				stFork: "London",
-			},
-			expOut: "exp.json",
-		},
-		{ // Transactions with value exceeding 256 bits
-			base: "./testdata/17",
-			input: t9nInput{
-				inTxs:  "signed_txs.rlp",
-				stFork: "London",
-			},
-			expOut: "exp.json",
-		},
-		{ // Invalid RLP
-			base: "./testdata/18",
-			input: t9nInput{
-				inTxs:  "invalid.rlp",
-				stFork: "London",
-			},
-			expExitCode: t8ntool.ErrorIO,
-		},
-	} {
-
-		args := []string{"t9n"}
-		args = append(args, tc.input.get(tc.base)...)
-
-		tt.Run("evm-test", args...)
-		tt.Logf("args:\n go run . %v\n", strings.Join(args, " "))
-		// Compare the expected output, if provided
-		if tc.expOut != "" {
-			want, err := os.ReadFile(fmt.Sprintf("%v/%v", tc.base, tc.expOut))
-			if err != nil {
-				t.Fatalf("test %d: could not read expected output: %v", i, err)
-			}
-			have := tt.Output()
-			ok, err := cmpJson(have, want)
-			switch {
-			case err != nil:
-				t.Logf(string(have))
-				t.Fatalf("test %d, json parsing failed: %v", i, err)
-			case !ok:
-				t.Fatalf("test %d: output wrong, have \n%v\nwant\n%v\n", i, string(have), string(want))
-			}
-		}
-		tt.WaitExit()
-		if have, want := tt.ExitStatus(), tc.expExitCode; have != want {
-			t.Fatalf("test %d: wrong exit code, have %d, want %d", i, have, want)
-		}
-	}
-}
-
-type b11rInput struct {
-	inEnv       string
-	inOmmersRlp string
-	inTxsRlp    string
-	inClique    string
-	ethash      bool
-	ethashMode  string
-	ethashDir   string
-}
-
-func (args *b11rInput) get(base string) []string {
-	var out []string
-	if opt := args.inEnv; opt != "" {
-		out = append(out, "--input.header")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.inOmmersRlp; opt != "" {
-		out = append(out, "--input.ommers")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.inTxsRlp; opt != "" {
-		out = append(out, "--input.txs")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.inClique; opt != "" {
-		out = append(out, "--seal.clique")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if args.ethash {
-		out = append(out, "--seal.ethash")
-	}
-	if opt := args.ethashMode; opt != "" {
-		out = append(out, "--seal.ethash.mode")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	if opt := args.ethashDir; opt != "" {
-		out = append(out, "--seal.ethash.dir")
-		out = append(out, fmt.Sprintf("%v/%v", base, opt))
-	}
-	out = append(out, "--output.block")
-	out = append(out, "stdout")
-	return out
-}
-
-func TestB11r(t *testing.T) {
-	tt := new(testT8n)
-	tt.TestCmd = cmdtest.NewTestCmd(t, tt)
-	for i, tc := range []struct {
-		base        string
-		input       b11rInput
-		expExitCode int
-		expOut      string
-	}{
-		{ // unsealed block
-			base: "./testdata/20",
-			input: b11rInput{
-				inEnv:       "header.json",
-				inOmmersRlp: "ommers.json",
-				inTxsRlp:    "txs.rlp",
-			},
-			expOut: "exp.json",
-		},
-		{ // ethash test seal
-			base: "./testdata/21",
-			input: b11rInput{
-				inEnv:       "header.json",
-				inOmmersRlp: "ommers.json",
-				inTxsRlp:    "txs.rlp",
-			},
-			expOut: "exp.json",
-		},
-		{ // clique test seal
-			base: "./testdata/21",
-			input: b11rInput{
-				inEnv:       "header.json",
-				inOmmersRlp: "ommers.json",
-				inTxsRlp:    "txs.rlp",
-				inClique:    "clique.json",
-			},
-			expOut: "exp-clique.json",
-		},
-		{ // block with ommers
-			base: "./testdata/22",
-			input: b11rInput{
-				inEnv:       "header.json",
-				inOmmersRlp: "ommers.json",
-				inTxsRlp:    "txs.rlp",
-			},
-			expOut: "exp.json",
-		},
-	} {
-
-		args := []string{"b11r"}
-		args = append(args, tc.input.get(tc.base)...)
-
-		tt.Run("evm-test", args...)
-		tt.Logf("args:\n go run . %v\n", strings.Join(args, " "))
-		// Compare the expected output, if provided
-		if tc.expOut != "" {
-			want, err := os.ReadFile(fmt.Sprintf("%v/%v", tc.base, tc.expOut))
-			if err != nil {
-				t.Fatalf("test %d: could not read expected output: %v", i, err)
-			}
-			have := tt.Output()
-			ok, err := cmpJson(have, want)
-			switch {
-			case err != nil:
-				t.Logf(string(have))
-				t.Fatalf("test %d, json parsing failed: %v", i, err)
-			case !ok:
-				t.Fatalf("test %d: output wrong, have \n%v\nwant\n%v\n", i, string(have), string(want))
-			}
-		}
-		tt.WaitExit()
-		if have, want := tt.ExitStatus(), tc.expExitCode; have != want {
-			t.Fatalf("test %d: wrong exit code, have %d, want %d", i, have, want)
-		}
-	}
-}
-
-// cmpJson compares the JSON in two byte slices.
-func cmpJson(a, b []byte) (bool, error) {
-	var j, j2 interface{}
-	if err := json.Unmarshal(a, &j); err != nil {
-		return false, err
-	}
-	if err := json.Unmarshal(b, &j2); err != nil {
-		return false, err
-	}
-	return reflect.DeepEqual(j2, j), nil
-}

cmd/evm/testdata/1/exp.json

@@ -1,44 +0,0 @@
-{
-  "alloc": {
-    "0x8a8eafb1cf62bfbeb1741769dae1a9dd47996192": {
-      "balance": "0xfeed1a9d",
-      "nonce": "0x1"
-    },
-    "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
-      "balance": "0x5ffd4878be161d74",
-      "nonce": "0xac"
-    },
-    "0xc94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
-      "balance": "0xa410"
-    }
-  },
-  "result": {
-    "stateRoot": "0x84208a19bc2b46ada7445180c1db162be5b39b9abc8c0a54b05d32943eae4e13",
-    "txRoot": "0xc4761fd7b87ff2364c7c60b6c5c8d02e522e815328aaea3f20e3b7b7ef52c42d",
-    "receiptsRoot": "0x056b23fbba480696b65fe5a59b8f2148a1299103c4f57df839233af2cf4ca2d2",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [
-      {
-        "root": "0x",
-        "status": "0x1",
-        "cumulativeGasUsed": "0x5208",
-        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        "logs": null,
-        "transactionHash": "0x0557bacce3375c98d806609b8d5043072f0b6a8bae45ae5a67a00d3a1a18d673",
-        "contractAddress": "0x0000000000000000000000000000000000000000",
-        "gasUsed": "0x5208",
-        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-        "transactionIndex": "0x0"
-      }
-    ],
-    "rejected": [
-      {
-        "index": 1,
-        "error": "nonce too low: address 0x8A8eAFb1cf62BfBeb1741769DAE1a9dd47996192, tx: 0 state: 1"
-      }
-    ],
-    "currentDifficulty": "0x20000",
-    "gasUsed": "0x5208"
-  }
-}

cmd/evm/testdata/13/exp.json

@@ -1,3 +0,0 @@
-{
-  "body": "0xf8d2b86702f864010180820fa08284d09411111111111111111111111111111111111111118080c001a0b7dfab36232379bb3d1497a4f91c1966b1f932eae3ade107bf5d723b9cb474e0a06261c359a10f2132f126d250485b90cf20f30340801244a08ef6142ab33d1904b86702f864010280820fa08284d09411111111111111111111111111111111111111118080c080a0d4ec563b6568cd42d998fc4134b36933c6568d01533b5adf08769270243c6c7fa072bf7c21eac6bbeae5143371eef26d5e279637f3bd73482b55979d76d935b1e9"
-}

cmd/evm/testdata/13/exp2.json

@@ -1,39 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0xe4b924a6adb5959fccf769d5b7bb2f6359e26d1e76a2443c5a91a36d826aef61",
-    "txRoot": "0x013509c8563d41c0ae4bf38f2d6d19fc6512a1d0d6be045079c8c9f68bf45f9d",
-    "receiptsRoot": "0xa532a08aa9f62431d6fe5d924951b8efb86ed3c54d06fee77788c3767dd13420",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [
-      {
-        "type": "0x2",
-        "root": "0x",
-        "status": "0x0",
-        "cumulativeGasUsed": "0x84d0",
-        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        "logs": null,
-        "transactionHash": "0xa98a24882ea90916c6a86da650fbc6b14238e46f0af04a131ce92be897507476",
-        "contractAddress": "0x0000000000000000000000000000000000000000",
-        "gasUsed": "0x84d0",
-        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-        "transactionIndex": "0x0"
-      },
-      {
-        "type": "0x2",
-        "root": "0x",
-        "status": "0x0",
-        "cumulativeGasUsed": "0x109a0",
-        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        "logs": null,
-        "transactionHash": "0x36bad80acce7040c45fd32764b5c2b2d2e6f778669fb41791f73f546d56e739a",
-        "contractAddress": "0x0000000000000000000000000000000000000000",
-        "gasUsed": "0x84d0",
-        "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-        "transactionIndex": "0x1"
-      }
-    ],
-    "currentDifficulty": "0x20000",
-    "gasUsed": "0x109a0"
-  }
-}

cmd/evm/testdata/13/signed_txs.rlp

@@ -1 +0,0 @@
-"0xf8d2b86702f864010180820fa08284d09411111111111111111111111111111111111111118080c001a0b7dfab36232379bb3d1497a4f91c1966b1f932eae3ade107bf5d723b9cb474e0a06261c359a10f2132f126d250485b90cf20f30340801244a08ef6142ab33d1904b86702f864010280820fa08284d09411111111111111111111111111111111111111118080c080a0d4ec563b6568cd42d998fc4134b36933c6568d01533b5adf08769270243c6c7fa072bf7c21eac6bbeae5143371eef26d5e279637f3bd73482b55979d76d935b1e9"

cmd/evm/testdata/14/alloc.json

@@ -1,12 +0,0 @@
-{
-  "a94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
-    "balance": "0x5ffd4878be161d74",
-    "code": "0x",
-    "nonce": "0xac",
-    "storage": {}
-  },
-  "0x8a8eafb1cf62bfbeb1741769dae1a9dd47996192":{
-    "balance": "0xfeedbead",
-    "nonce" : "0x00"
-  }
-}

cmd/evm/testdata/14/env.json

@@ -1,9 +0,0 @@
-{
-  "currentCoinbase": "0xc94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-  "currentGasLimit": "0x750a163df65e8a",
-  "currentBaseFee": "0x500",
-  "currentNumber": "12800000",
-  "currentTimestamp": "100015",
-  "parentTimestamp" : "99999",
-  "parentDifficulty" : "0x2000000000000"
-}

cmd/evm/testdata/14/env.uncles.json

@@ -1,10 +0,0 @@
-{
-  "currentCoinbase": "0xc94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-  "currentGasLimit": "0x750a163df65e8a",
-  "currentBaseFee": "0x500",
-  "currentNumber": "12800000",
-  "currentTimestamp": "100035",
-  "parentTimestamp" : "99999",
-  "parentDifficulty" : "0x2000000000000",
-  "parentUncleHash" : "0x000000000000000000000000000000000000000000000000000000000000beef"
-}

cmd/evm/testdata/14/exp.json

@@ -1,12 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "currentDifficulty": "0x2000020000000",
-    "receipts": [],
-    "gasUsed": "0x0"
-  }
-}

cmd/evm/testdata/14/exp2.json

@@ -1,12 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [],
-    "currentDifficulty": "0x1ff8020000000",
-    "gasUsed": "0x0"
-  }
-}

cmd/evm/testdata/14/exp_berlin.json

@@ -1,12 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [],
-    "currentDifficulty": "0x1ff9000000000",
-    "gasUsed": "0x0"
-  }
-}

cmd/evm/testdata/14/readme.md

@@ -1,41 +0,0 @@
-## Difficulty calculation
-
-This test shows how the `evm t8n` can be used to calculate the (ethash) difficulty, if none is provided by the caller. 
-
-Calculating it (with an empty set of txs) using `London` rules (and no provided unclehash for the parent block):
-```
-[user@work evm]$ ./evm t8n --input.alloc=./testdata/14/alloc.json --input.txs=./testdata/14/txs.json --input.env=./testdata/14/env.json --output.result=stdout --state.fork=London
-INFO [08-30|20:43:09.352] Trie dumping started                     root=6f0588..7f4bdc
-INFO [08-30|20:43:09.352] Trie dumping complete                    accounts=2 elapsed="82.533µs"
-INFO [08-30|20:43:09.352] Wrote file                               file=alloc.json
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [],
-    "currentDifficulty": "0x2000020000000"
-  }
-}
-```
-Same thing, but this time providing a non-empty (and non-`emptyKeccak`) unclehash, which leads to a slightly different result:
-```
-[user@work evm]$ ./evm t8n --input.alloc=./testdata/14/alloc.json --input.txs=./testdata/14/txs.json --input.env=./testdata/14/env.uncles.json --output.result=stdout --state.fork=London
-INFO [08-30|20:44:33.102] Trie dumping started                     root=6f0588..7f4bdc
-INFO [08-30|20:44:33.102] Trie dumping complete                    accounts=2 elapsed="72.91µs"
-INFO [08-30|20:44:33.102] Wrote file                               file=alloc.json
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "receipts": [],
-    "currentDifficulty": "0x1ff8020000000"
-  }
-}
-```
-

cmd/evm/testdata/14/txs.json

@@ -1 +0,0 @@
-[]

cmd/evm/testdata/15/blockheader.rlp

@@ -1 +0,0 @@
-"0xf901f0a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000000b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007b0101020383010203a00000000000000000000000000000000000000000000000000000000000000000880000000000000000"

cmd/evm/testdata/15/exp.json

@@ -1,10 +0,0 @@
-[
-  {
-    "error": "transaction type not supported",
-    "hash": "0xa98a24882ea90916c6a86da650fbc6b14238e46f0af04a131ce92be897507476"
-  },
-  {
-    "error": "transaction type not supported",
-    "hash": "0x36bad80acce7040c45fd32764b5c2b2d2e6f778669fb41791f73f546d56e739a"
-  }
-]

cmd/evm/testdata/15/exp2.json

@@ -1,12 +0,0 @@
-[
-  {
-    "address": "0xd02d72e067e77158444ef2020ff2d325f929b363",
-    "hash": "0xa98a24882ea90916c6a86da650fbc6b14238e46f0af04a131ce92be897507476",
-    "intrinsicGas": "0x5208"
-  },
-  {
-    "address": "0xd02d72e067e77158444ef2020ff2d325f929b363",
-    "hash": "0x36bad80acce7040c45fd32764b5c2b2d2e6f778669fb41791f73f546d56e739a",
-    "intrinsicGas": "0x5208"
-  }
-]

cmd/evm/testdata/15/exp3.json

@@ -1,47 +0,0 @@
-[
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "typed transaction too short"
-  },
-  {
-    "error": "typed transaction too short"
-  },
-  {
-    "error": "typed transaction too short"
-  },
-  {
-    "error": "typed transaction too short"
-  },
-  {
-    "error": "typed transaction too short"
-  },
-  {
-    "error": "rlp: expected input list for types.AccessListTx"
-  },
-  {
-    "error": "transaction type not supported"
-  },
-  {
-    "error": "transaction type not supported"
-  }
-]

cmd/evm/testdata/15/signed_txs.rlp

@@ -1 +0,0 @@
-"0xf8d2b86702f864010180820fa08284d09411111111111111111111111111111111111111118080c001a0b7dfab36232379bb3d1497a4f91c1966b1f932eae3ade107bf5d723b9cb474e0a06261c359a10f2132f126d250485b90cf20f30340801244a08ef6142ab33d1904b86702f864010280820fa08284d09411111111111111111111111111111111111111118080c080a0d4ec563b6568cd42d998fc4134b36933c6568d01533b5adf08769270243c6c7fa072bf7c21eac6bbeae5143371eef26d5e279637f3bd73482b55979d76d935b1e9"

cmd/evm/testdata/15/signed_txs.rlp.json

@@ -1,4 +0,0 @@
-{
- "txsRlp" : "0xf8d2b86702f864010180820fa08284d09411111111111111111111111111111111111111118080c001a0b7dfab36232379bb3d1497a4f91c1966b1f932eae3ade107bf5d723b9cb474e0a06261c359a10f2132f126d250485b90cf20f30340801244a08ef6142ab33d1904b86702f864010280820fa08284d09411111111111111111111111111111111111111118080c080a0d4ec563b6568cd42d998fc4134b36933c6568d01533b5adf08769270243c6c7fa072bf7c21eac6bbeae5143371eef26d5e279637f3bd73482b55979d76d935b1e9"
-}
-

cmd/evm/testdata/16/exp.json

@@ -1,13 +0,0 @@
-[
-  {
-    "address": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-    "hash": "0x7cc3d1a8540a44736750f03bb4d85c0113be4b3472a71bf82241a3b261b479e6",
-    "intrinsicGas": "0x5208"
-  },
-  {
-    "error": "intrinsic gas too low: have 82, want 21000",
-    "address": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-    "hash": "0x3b2d2609e4361562edb9169314f4c05afc6dbf5d706bf9dda5abe242ab76a22b",
-    "intrinsicGas": "0x5208"
-  }
-]

cmd/evm/testdata/16/signed_txs.rlp

@@ -1 +0,0 @@
-"0xf8cab86401f8610180018252089411111111111111111111111111111111111111112080c001a0937f65ef1deece46c473b99962678fb7c38425cf303d1e8fa9717eb4b9d012b5a01940c5a5647c4940217ffde1051a5fd92ec8551e275c1787f81f50a2ad84de43b86201f85f018001529411111111111111111111111111111111111111112080c001a0241c3aec732205542a87fef8c76346741e85480bce5a42d05a9a73dac892f84ca04f52e2dfce57f3a02ed10e085e1a154edf38a726da34127c85fc53b4921759c8"

cmd/evm/testdata/16/unsigned_txs.json

@@ -1,34 +0,0 @@
-[
-  {
-    "input" : "0x",
-    "gas" : "0x5208",
-    "nonce" : "0x0",
-    "to" : "0x1111111111111111111111111111111111111111",
-    "value" : "0x20",
-    "v" : "0x0",
-    "r" : "0x0",
-    "s" : "0x0",
-    "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
-    "chainId" : "0x1",
-    "type" : "0x1",
-    "gasPrice": "0x1",
-    "accessList" : [
-    ]
-  },
-  {
-    "input" : "0x",
-    "gas" : "0x52",
-    "nonce" : "0x0",
-    "to" : "0x1111111111111111111111111111111111111111",
-    "value" : "0x20",
-    "v" : "0x0",
-    "r" : "0x0",
-    "s" : "0x0",
-    "secretKey" : "0x45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
-    "chainId" : "0x1",
-    "type" : "0x1",
-    "gasPrice": "0x1",
-    "accessList" : [
-    ]
-  }
-]

cmd/evm/testdata/17/exp.json

@@ -1,22 +0,0 @@
- [
-    {
-      "error": "value exceeds 256 bits",
-      "address": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-      "hash": "0xfbd91685dcbf8172f0e8c53e2ddbb4d26707840da6b51a74371f62a33868fd82",
-      "intrinsicGas": "0x5208"
-    },
-    {
-      "error": "gasPrice exceeds 256 bits",
-      "address": "0x1b57ccef1fe5fb73f1e64530fb4ebd9cf1655964",
-      "hash": "0x45dc05035cada83748e4c1fe617220106b331eca054f44c2304d5654a9fb29d5",
-      "intrinsicGas": "0x5208"
-    },
-    {
-      "error": "invalid transaction v, r, s values",
-      "hash": "0xf06691c2a803ab7f3c81d06a0c0a896f80f311105c599fc59a9fdbc669356d35"
-    },
-    {
-      "error": "invalid transaction v, r, s values",
-      "hash": "0x84703b697ad5b0db25e4f1f98fb6b1adce85b9edb2232eeba9cedd8c6601694b"
-    }
-]

cmd/evm/testdata/17/rlpdata.txt

@@ -1,46 +0,0 @@
-[
-  [
-    "",
-    "d",
-    5208,
-    d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0,
-    010000000000000000000000000000000000000000000000000000000000000001,
-    "",
-    1b,
-    c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549d,
-    6180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28,
-  ],
-  [
-    "",
-    010000000000000000000000000000000000000000000000000000000000000001,
-    5208,
-    d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0,
-    11,
-    "",
-    1b,
-    c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549d,
-    6180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28,
-  ],
-  [
-    "",
-    11,
-    5208,
-    d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0,
-    11,
-    "",
-    1b,
-    c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549daa,
-    6180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28,
-  ],
-  [
-    "",
-    11,
-    5208,
-    d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0,
-    11,
-    "",
-    1b,
-    c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549d,
-    6180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28bb,
-  ],
-]

cmd/evm/testdata/17/signed_txs.rlp

@@ -1 +0,0 @@
-"0xf901c8f880806482520894d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0a1010000000000000000000000000000000000000000000000000000000000000001801ba0c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549da06180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28f88080a101000000000000000000000000000000000000000000000000000000000000000182520894d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d011801ba0c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549da06180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28f860801182520894d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d011801ba1c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549daaa06180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28f860801182520894d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d011801ba0c16787a8e25e941d67691954642876c08f00996163ae7dfadbbfd6cd436f549da16180e5626cae31590f40641fe8f63734316c4bfeb4cdfab6714198c1044d2e28bb"

cmd/evm/testdata/18/README.md

@@ -1,9 +0,0 @@
-# Invalid rlp
-
-This folder contains a sample of invalid RLP, and it's expected
-that the t9n handles this properly: 
-
-```
-$ go run . t9n --input.txs=./testdata/18/invalid.rlp --state.fork=London 
-ERROR(11): rlp: value size exceeds available input length
-```

cmd/evm/testdata/18/invalid.rlp

@@ -1 +0,0 @@
-"0xf852328001825208870b9331677e6ebf0a801ca098ff921201554726367d2be8c804a7ff89ccf285ebc57dff8ae4c44b9c19ac4aa03887321be575c8095f789dd4c743dfe42c1820f9231f98a962b210e3ac2452a3"

cmd/evm/testdata/19/alloc.json

@@ -1,12 +0,0 @@
-{
-  "a94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
-    "balance": "0x5ffd4878be161d74",
-    "code": "0x",
-    "nonce": "0xac",
-    "storage": {}
-  },
-  "0x8a8eafb1cf62bfbeb1741769dae1a9dd47996192":{
-    "balance": "0xfeedbead",
-    "nonce" : "0x00"
-  }
-}

cmd/evm/testdata/19/env.json

@@ -1,9 +0,0 @@
-{
-  "currentCoinbase": "0xc94f5374fce5edbc8e2a8697c15331677e6ebf0b",
-  "currentGasLimit": "0x750a163df65e8a",
-  "currentBaseFee": "0x500",
-  "currentNumber": "13000000",
-  "currentTimestamp": "100015",
-  "parentTimestamp" : "99999",
-  "parentDifficulty" : "0x2000000000000"
-}

cmd/evm/testdata/19/exp_arrowglacier.json

@@ -1,12 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "currentDifficulty": "0x2000000200000",
-    "receipts": [],
-    "gasUsed": "0x0"
-  }
-}

cmd/evm/testdata/19/exp_london.json

@@ -1,12 +0,0 @@
-{
-  "result": {
-    "stateRoot": "0x6f058887ca01549716789c380ede95aecc510e6d1fdc4dbf67d053c7c07f4bdc",
-    "txRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "receiptsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
-    "logsHash": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-    "currentDifficulty": "0x2000080000000",
-    "receipts": [],
-    "gasUsed": "0x0"
-  }
-}

cmd/evm/testdata/19/readme.md

@@ -1,9 +0,0 @@
-## Difficulty calculation
-
-This test shows how the `evm t8n` can be used to calculate the (ethash) difficulty, if none is provided by the caller, 
-this time on `ArrowGlacier` (Eip 4345).
-
-Calculating it (with an empty set of txs) using `ArrowGlacier` rules (and no provided unclehash for the parent block):
-```
-[user@work evm]$ ./evm t8n --input.alloc=./testdata/14/alloc.json --input.txs=./testdata/14/txs.json --input.env=./testdata/14/env.json --output.result=stdout --state.fork=ArrowGlacier
-```