Bump version to v0.2.8 (#1572 )

## Issue Addressed NA ## Proposed Changes - Bump versions - Run `cargo update` ## Additional Info NA
Alternative (to BeaconChainHarness) BeaconChain testing API (#1380 )
2026-03-03 08:41:43 +00:00 · 2020-08-27 07:04:12 +00:00 · 2020-08-26 09:24:55 +00:00 · 2020-08-26 00:01:08 +00:00 · 2020-08-26 00:01:06 +00:00 · 2020-08-25 06:01:42 +00:00
61 changed files with 3358 additions and 2354 deletions
--- a/.github/workflows/test-suite.yml
+++ b/.github/workflows/test-suite.yml
@@ -123,6 +123,8 @@ jobs:
    - uses: actions/checkout@v1
    - name: Lint code for quality and style with Clippy
      run: make lint
+    - name: Certify Cargo.lock freshness
+      run: git diff --exit-code Cargo.lock
  arbitrary-check:
    name: arbitrary-check
    runs-on: ubuntu-latest
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,7 +2,7 @@
 # It is not intended for manual editing.
 [[package]]
 name = "account_manager"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
 "account_utils",
 "bls",
@@ -182,9 +182,9 @@ checksum = "6b602bfe940d21c130f3895acd65221e8a61270debe89d628b9cb4e3ccb8569b"

 [[package]]
 name = "arbitrary"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cb544f1057eaaff4b34f8c4dcf56fc3cd04debd291998405d135017a7c3c0f4"
+checksum = "0922a3e746b5a44e111e5603feb6704e5cc959116f66737f50bb5cbd264e9d87"
 dependencies = [
 "derive_arbitrary",
 ]
@@ -275,9 +275,9 @@ checksum = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"

 [[package]]
 name = "autocfg"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

 [[package]]
 name = "backtrace"
@@ -346,11 +346,13 @@ dependencies = [
 "lighthouse_metrics",
 "log 0.4.11",
 "lru",
+ "maplit",
 "merkle_proof",
 "operation_pool",
 "parking_lot 0.11.0",
 "proto_array",
 "rand 0.7.3",
+ "rand_core 0.5.1",
 "rayon",
 "safe_arith",
 "serde",
@@ -373,7 +375,7 @@ dependencies = [

 [[package]]
 name = "beacon_node"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
 "beacon_chain",
 "clap",
@@ -460,13 +462,28 @@ dependencies = [
 "constant_time_eq",
 ]

+[[package]]
+name = "blake3"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce4f9586c9a3151c4b49b19e82ba163dd073614dd057e53c969e1a4db5b52720"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "crypto-mac 0.8.0",
+ "digest 0.9.0",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
 dependencies = [
- "block-padding",
+ "block-padding 0.1.5",
 "byte-tools",
 "byteorder",
 "generic-array 0.12.3",
@@ -478,6 +495,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
+ "block-padding 0.2.1",
 "generic-array 0.14.4",
 ]

@@ -499,6 +517,12 @@ dependencies = [
 "byte-tools",
 ]

+[[package]]
+name = "block-padding"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
+
 [[package]]
 name = "bls"
 version = "0.2.0"
@@ -530,8 +554,9 @@ dependencies = [

 [[package]]
 name = "boot_node"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
+ "beacon_node",
 "clap",
 "discv5",
 "eth2_libp2p",
@@ -691,7 +716,7 @@ checksum = "942f72db697d8767c22d46a598e01f2d3b475501ea43d0db4f16d90259182d0b"
 dependencies = [
 "num-integer",
 "num-traits",
- "time 0.1.43",
+ "time 0.1.44",
 ]

 [[package]]
@@ -958,7 +983,7 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "cfg-if",
 "crossbeam-utils",
 "lazy_static",
@@ -984,7 +1009,7 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "cfg-if",
 "lazy_static",
 ]
@@ -1069,6 +1094,19 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "curve25519-dalek"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8492de420e9e60bc9a1d66e2dbb91825390b738a388606600663fc529b4b307"
+dependencies = [
+ "byteorder",
+ "digest 0.9.0",
+ "rand_core 0.5.1",
+ "subtle 2.2.3",
+ "zeroize",
+]
+
 [[package]]
 name = "darwin-libproc"
 version = "0.1.2"
@@ -1128,9 +1166,9 @@ dependencies = [

 [[package]]
 name = "derive_arbitrary"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b43185d3e7ce7dcd44a23ca761ec026359753ebf480283a571e6463853d2ef"
+checksum = "d0f7c6c81276b6b8702074defbdb1938933ddf98c7f7e0dca8d9e9214dd6c730"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1247,15 +1285,15 @@ dependencies = [

 [[package]]
 name = "ed25519-dalek"
-version = "1.0.0-pre.4"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a8a37f4e8b35af971e6db5e3897e7a6344caa3f92f6544f88125a1f5f0035a"
+checksum = "53d2e93f837d749c16d118e7ddf7a4dfd0ac8f452cf51e46e9348824e5ef6851"
 dependencies = [
- "curve25519-dalek",
+ "curve25519-dalek 3.0.0",
 "ed25519",
 "rand 0.7.3",
 "serde",
- "sha2 0.8.2",
+ "sha2 0.9.1",
 "zeroize",
 ]

@@ -1290,9 +1328,9 @@ checksum = "cd56b59865bce947ac5958779cfa508f6c3b9497cc762b7e24a12d11ccde2c4f"

 [[package]]
 name = "encoding_rs"
-version = "0.8.23"
+version = "0.8.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8ac63f94732332f44fe654443c46f6375d1939684c17b0afb6cb56b0456e171"
+checksum = "a51b8cf747471cb9499b6d59e59b0444f4c90eba8968c4e44874e92b5b64ace2"
 dependencies = [
 "cfg-if",
 ]
@@ -1512,7 +1550,7 @@ dependencies = [
 "tokio-io-timeout",
 "tokio-util",
 "types",
- "unsigned-varint 0.3.3 (git+https://github.com/sigp/unsigned-varint?branch=latest-codecs)",
+ "unsigned-varint 0.3.3",
 "void",
 ]

@@ -1978,7 +2016,7 @@ checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
 dependencies = [
 "cfg-if",
 "libc",
- "wasi",
+ "wasi 0.9.0+wasi-snapshot-preview1",
 ]

 [[package]]
@@ -2097,7 +2135,7 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91b62f79061a0bc2e046024cb7ba44b08419ed238ecbd9adbd787434b9e8c25"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 ]

 [[package]]
@@ -2256,7 +2294,7 @@ dependencies = [
 "log 0.3.9",
 "mime 0.2.6",
 "num_cpus",
- "time 0.1.43",
+ "time 0.1.44",
 "traitobject",
 "typeable",
 "unicase 1.4.2",
@@ -2281,7 +2319,7 @@ dependencies = [
 "log 0.4.11",
 "net2",
 "rustc_version",
- "time 0.1.43",
+ "time 0.1.44",
 "tokio 0.1.22",
 "tokio-buf",
 "tokio-executor",
@@ -2310,7 +2348,7 @@ dependencies = [
 "itoa",
 "pin-project",
 "socket2",
- "time 0.1.43",
+ "time 0.1.44",
 "tokio 0.2.22",
 "tower-service",
 "tracing",
@@ -2398,7 +2436,7 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b45e59b16c76b11bf9738fd5d38879d3bd28ad292d7b313608becb17ae2df9"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "hashbrown 0.8.2",
 ]

@@ -2523,7 +2561,7 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"

 [[package]]
 name = "lcli"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
 "bls",
 "clap",
@@ -2576,9 +2614,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.74"
+version = "0.2.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2f02823cf78b754822df5f7f268fb59822e7296276d3e069d8e8cb26a14bd10"
+checksum = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"

 [[package]]
 name = "libflate"
@@ -2777,7 +2815,7 @@ version = "0.23.0"
 source = "git+https://github.com/sigp/rust-libp2p?rev=bbf0cfbaff2f733b3ae7bfed3caba8b7ee542803#bbf0cfbaff2f733b3ae7bfed3caba8b7ee542803"
 dependencies = [
 "bytes 0.5.6",
- "curve25519-dalek",
+ "curve25519-dalek 2.1.0",
 "futures 0.3.5",
 "lazy_static",
 "libp2p-core 0.21.0",
@@ -2880,7 +2918,7 @@ dependencies = [

 [[package]]
 name = "lighthouse"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
 "account_manager",
 "account_utils",
@@ -3044,7 +3082,7 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c198b026e1bbf08a937e94c6c60f9ec4a2267f5b0d2eec9c1b21b061ce2be55f"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 ]

 [[package]]
@@ -3098,9 +3136,9 @@ dependencies = [

 [[package]]
 name = "miniz_oxide"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be0f75932c1f6cfae3c04000e40114adf955636e19040f9c0a2c380702aa1c7f"
+checksum = "4d7559a8a40d0f97e1edea3220f698f78b1c5ab67532e49f68fde3910323b722"
 dependencies = [
 "adler",
 ]
@@ -3183,24 +3221,25 @@ dependencies = [

 [[package]]
 name = "multihash"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f75db05d738947aa5389863aadafbcf2e509d7ba099dc2ddcdf4fc66bf7a9e03"
+checksum = "51cc1552a982658478dbc22eefb72bb1d4fd1161eb9818f7bbf4347443f07569"
 dependencies = [
 "blake2b_simd",
 "blake2s_simd",
- "digest 0.8.1",
- "sha-1",
- "sha2 0.8.2",
+ "blake3",
+ "digest 0.9.0",
+ "sha-1 0.9.1",
+ "sha2 0.9.1",
 "sha3",
- "unsigned-varint 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "unsigned-varint 0.5.0",
 ]

 [[package]]
 name = "multimap"
-version = "0.8.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8883adfde9756c1d30b0f519c9b8c502a94b41ac62f696453c37c7fc0a958ce"
+checksum = "1255076139a83bb467426e7f8d0134968a8118844faa755985e077cf31850333"

 [[package]]
 name = "multistream-select"
@@ -3340,7 +3379,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f3fc75e3697059fb1bc465e3d8cca6cf92f56854f201158b3f9c77d5a3cfa0"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "num-integer",
 "num-traits",
 ]
@@ -3370,7 +3409,7 @@ version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "num-traits",
 ]

@@ -3380,7 +3419,7 @@ version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a6e6b7c748f995c4c29c5f5ae0248536e04a5739927c74ec0fa564805094b9f"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "num-integer",
 "num-traits",
 ]
@@ -3391,7 +3430,7 @@ version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 ]

 [[package]]
@@ -3472,7 +3511,7 @@ version = "0.9.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "cc",
 "libc",
 "openssl-src",
@@ -3690,7 +3729,7 @@ checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d"
 dependencies = [
 "maplit",
 "pest",
- "sha-1",
+ "sha-1 0.8.2",
 ]

 [[package]]
@@ -3780,9 +3819,9 @@ dependencies = [

 [[package]]
 name = "ppv-lite86"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
+checksum = "c36fa947111f5c62a733b652544dd0016a43ce89619538a8ef92724a6f501a20"

 [[package]]
 name = "primitive-types"
@@ -4107,11 +4146,11 @@ dependencies = [

 [[package]]
 name = "rayon"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62f02856753d04e03e26929f820d0a0a337ebe71f849801eea335d464b349080"
+checksum = "cfd016f0c045ad38b5251be2c9c0ab806917f82da4d36b2a327e5166adad9270"
 dependencies = [
- "autocfg 1.0.0",
+ "autocfg 1.0.1",
 "crossbeam-deque",
 "either",
 "rayon-core",
@@ -4119,12 +4158,12 @@ dependencies = [

 [[package]]
 name = "rayon-core"
-version = "1.7.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e92e15d89083484e11353891f1af602cc661426deb9564c298b270c726973280"
+checksum = "91739a34c4355b5434ce54c9086c5895604a9c278586d1f1aa95e04f66b525a0"
 dependencies = [
+ "crossbeam-channel",
 "crossbeam-deque",
- "crossbeam-queue",
 "crossbeam-utils",
 "lazy_static",
 "num_cpus",
@@ -4147,9 +4186,9 @@ checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"

 [[package]]
 name = "redox_users"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b23093265f8d200fa7b4c2c76297f47e681c655f6f1285a8780d6a022f7431"
+checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
 dependencies = [
 "getrandom",
 "redox_syscall",
@@ -4212,9 +4251,9 @@ dependencies = [

 [[package]]
 name = "reqwest"
-version = "0.10.7"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12427a5577082c24419c9c417db35cfeb65962efc7675bb6b0d5f1f9d315bfe6"
+checksum = "e9eaa17ac5d7b838b7503d118fa16ad88f440498bf9ffe5424e621f93190d61e"
 dependencies = [
 "base64 0.12.3",
 "bytes 0.5.6",
@@ -4271,7 +4310,6 @@ dependencies = [
 "node_test_rig",
 "operation_pool",
 "parking_lot 0.11.0",
- "rayon",
 "remote_beacon_node",
 "rest_types",
 "serde",
@@ -4294,15 +4332,22 @@ dependencies = [
 name = "rest_types"
 version = "0.2.0"
 dependencies = [
+ "beacon_chain",
 "bls",
+ "environment",
 "eth2_hashing",
 "eth2_ssz",
 "eth2_ssz_derive",
+ "hyper 0.13.7",
 "procinfo",
 "psutil",
 "rayon",
 "serde",
+ "serde_json",
+ "serde_yaml",
 "state_processing",
+ "store",
+ "tokio 0.2.22",
 "tree_hash",
 "types",
 ]
@@ -4360,16 +4405,16 @@ dependencies = [
 "lru-cache",
 "memchr",
 "smallvec 1.4.2",
- "time 0.1.43",
+ "time 0.1.44",
 ]

 [[package]]
 name = "rust-argon2"
-version = "0.7.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bc8af4bda8e1ff4932523b94d3dd20ee30a87232323eda55903ffd71d2fb017"
+checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19"
 dependencies = [
- "base64 0.11.0",
+ "base64 0.12.3",
 "blake2b_simd",
 "constant_time_eq",
 "crossbeam-utils",
@@ -4667,6 +4712,19 @@ dependencies = [
 "opaque-debug 0.2.3",
 ]

+[[package]]
+name = "sha-1"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170a36ea86c864a3f16dd2687712dd6646f7019f301e57537c7f4dc9f5916770"
+dependencies = [
+ "block-buffer 0.9.0",
+ "cfg-if",
+ "cpuid-bool",
+ "digest 0.9.0",
+ "opaque-debug 0.3.0",
+]
+
 [[package]]
 name = "sha1"
 version = "0.6.0"
@@ -4700,15 +4758,14 @@ dependencies = [

 [[package]]
 name = "sha3"
-version = "0.8.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
+checksum = "f81199417d4e5de3f04b1e871023acea7389672c4135918f05aa9cbf2f2fa809"
 dependencies = [
- "block-buffer 0.7.3",
- "byte-tools",
- "digest 0.8.1",
+ "block-buffer 0.9.0",
+ "digest 0.9.0",
 "keccak",
- "opaque-debug 0.2.3",
+ "opaque-debug 0.3.0",
 ]

 [[package]]
@@ -4972,7 +5029,7 @@ dependencies = [
 "httparse",
 "log 0.4.11",
 "rand 0.7.3",
- "sha-1",
+ "sha-1 0.8.2",
 ]

 [[package]]
@@ -4983,9 +5040,9 @@ checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

 [[package]]
 name = "standback"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0437cfb83762844799a60e1e3b489d5ceb6a650fbacb86437badc1b6d87b246"
+checksum = "33a71ea1ea5f8747d1af1979bfb7e65c3a025a70609f04ceb78425bc5adad8e6"
 dependencies = [
 "version_check 0.9.2",
 ]
@@ -5154,9 +5211,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "1.0.38"
+version = "1.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e69abc24912995b3038597a7a593be5053eb0fb44f3cc5beec0deb421790c1f4"
+checksum = "891d8d6567fe7c7f8835a3a98af4208f3846fba258c1bc3c31d6e506239f11f9"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -5287,11 +5344,12 @@ dependencies = [

 [[package]]
 name = "time"
-version = "0.1.43"
+version = "0.1.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
+checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
 dependencies = [
 "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
 "winapi 0.3.9",
 ]

@@ -5745,9 +5803,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.14"
+version = "0.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db63662723c316b43ca36d833707cc93dff82a02ba3d7e354f342682cc8b3545"
+checksum = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
 dependencies = [
 "lazy_static",
 ]
@@ -5960,12 +6018,6 @@ dependencies = [
 "tokio-util",
 ]

-[[package]]
-name = "unsigned-varint"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f67332660eb59a6f1eb24ff1220c9e8d01738a8503c6002e30bcfe4bd9f2b4a9"
-
 [[package]]
 name = "unsigned-varint"
 version = "0.4.0"
@@ -5976,6 +6028,12 @@ dependencies = [
 "futures_codec",
 ]

+[[package]]
+name = "unsigned-varint"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a98e44fc6af1e18c3a06666d829b4fd8d2714fb2dbffe8ab99d5dc7ea6baa628"
+
 [[package]]
 name = "untrusted"
 version = "0.7.1"
@@ -6016,7 +6074,7 @@ dependencies = [

 [[package]]
 name = "validator_client"
-version = "0.2.6"
+version = "0.2.8"
 dependencies = [
 "account_utils",
 "bls",
@@ -6139,6 +6197,12 @@ version = "0.9.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"

+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.67"
@@ -6429,7 +6493,7 @@ dependencies = [
 "mio",
 "mio-extras",
 "rand 0.7.3",
- "sha-1",
+ "sha-1 0.8.2",
 "slab 0.4.2",
 "url 2.1.1",
 ]
@@ -6450,7 +6514,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "637ff90c9540fa3073bb577e65033069e4bae7c79d49d74aa3ffdf5342a53217"
 dependencies = [
- "curve25519-dalek",
+ "curve25519-dalek 2.1.0",
 "rand_core 0.5.1",
 "zeroize",
 ]
--- a/account_manager/Cargo.toml
+++ b/account_manager/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "account_manager"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Paul Hauner <paul@paulhauner.com>", "Luke Anderson <luke@sigmaprime.io>"]
 edition = "2018"

--- a/beacon_node/Cargo.toml
+++ b/beacon_node/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "beacon_node"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com"]
 edition = "2018"

--- a/beacon_node/beacon_chain/Cargo.toml
+++ b/beacon_node/beacon_chain/Cargo.toml
@@ -11,6 +11,7 @@ participation_metrics = []  # Exposes validator participation metrics to Prometh

 [dev-dependencies]
 int_to_bytes = { path = "../../consensus/int_to_bytes" }
+maplit = "1.0.2"

 [dependencies]
 eth2_config = { path = "../../common/eth2_config" }
@@ -45,6 +46,7 @@ futures = "0.3.5"
 genesis = { path = "../genesis" }
 integer-sqrt = "0.1.3"
 rand = "0.7.3"
+rand_core = "0.5.1"
 proto_array = { path = "../../consensus/proto_array" }
 lru = "0.5.1"
 tempfile = "3.1.0"
--- a/beacon_node/beacon_chain/src/beacon_chain.rs
+++ b/beacon_node/beacon_chain/src/beacon_chain.rs
@@ -426,6 +426,17 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
        Ok(iter)
    }

+    /// As for `rev_iter_state_roots` but starting from an arbitrary `BeaconState`.
+    pub fn rev_iter_state_roots_from<'a>(
+        &self,
+        state_root: Hash256,
+        state: &'a BeaconState<T::EthSpec>,
+    ) -> impl Iterator<Item = Result<(Hash256, Slot), Error>> + 'a {
+        std::iter::once(Ok((state_root, state.slot)))
+            .chain(StateRootsIterator::new(self.store.clone(), state))
+            .map(|result| result.map_err(Into::into))
+    }
+
    /// Returns the block at the given slot, if any. Only returns blocks in the canonical chain.
    ///
    /// ## Errors
@@ -479,30 +490,36 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
    /// is the state as it was when the head block was received, which could be some slots prior to
    /// now.
    pub fn head(&self) -> Result<BeaconSnapshot<T::EthSpec>, Error> {
-        self.canonical_head
+        self.with_head(|head| Ok(head.clone_with_only_committee_caches()))
+    }
+
+    /// Apply a function to the canonical head without cloning it.
+    pub fn with_head<U>(
+        &self,
+        f: impl FnOnce(&BeaconSnapshot<T::EthSpec>) -> Result<U, Error>,
+    ) -> Result<U, Error> {
+        let head_lock = self
+            .canonical_head
            .try_read_for(HEAD_LOCK_TIMEOUT)
-            .ok_or_else(|| Error::CanonicalHeadLockTimeout)
-            .map(|v| v.clone_with_only_committee_caches())
+            .ok_or_else(|| Error::CanonicalHeadLockTimeout)?;
+        f(&head_lock)
    }

    /// Returns info representing the head block and state.
    ///
    /// A summarized version of `Self::head` that involves less cloning.
    pub fn head_info(&self) -> Result<HeadInfo, Error> {
-        let head = self
-            .canonical_head
-            .try_read_for(HEAD_LOCK_TIMEOUT)
-            .ok_or_else(|| Error::CanonicalHeadLockTimeout)?;
-
-        Ok(HeadInfo {
-            slot: head.beacon_block.slot(),
-            block_root: head.beacon_block_root,
-            state_root: head.beacon_state_root,
-            current_justified_checkpoint: head.beacon_state.current_justified_checkpoint,
-            finalized_checkpoint: head.beacon_state.finalized_checkpoint,
-            fork: head.beacon_state.fork,
-            genesis_time: head.beacon_state.genesis_time,
-            genesis_validators_root: head.beacon_state.genesis_validators_root,
+        self.with_head(|head| {
+            Ok(HeadInfo {
+                slot: head.beacon_block.slot(),
+                block_root: head.beacon_block_root,
+                state_root: head.beacon_state_root,
+                current_justified_checkpoint: head.beacon_state.current_justified_checkpoint,
+                finalized_checkpoint: head.beacon_state.finalized_checkpoint,
+                fork: head.beacon_state.fork,
+                genesis_time: head.beacon_state.genesis_time,
+                genesis_validators_root: head.beacon_state.genesis_validators_root,
+            })
        })
    }

@@ -1746,7 +1763,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
        let beacon_block_root = self.fork_choice.write().get_head(self.slot()?)?;

        let current_head = self.head_info()?;
-        let old_finalized_root = current_head.finalized_checkpoint.root;
+        let old_finalized_checkpoint = current_head.finalized_checkpoint;

        if beacon_block_root == current_head.block_root {
            return Ok(());
@@ -1826,15 +1843,32 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
            );
        };

-        let old_finalized_epoch = current_head.finalized_checkpoint.epoch;
-        let new_finalized_epoch = new_head.beacon_state.finalized_checkpoint.epoch;
-        let finalized_root = new_head.beacon_state.finalized_checkpoint.root;
+        let new_finalized_checkpoint = new_head.beacon_state.finalized_checkpoint;
+        // State root of the finalized state on the epoch boundary, NOT the state
+        // of the finalized block. We need to use an iterator in case the state is beyond
+        // the reach of the new head's `state_roots` array.
+        let new_finalized_slot = new_finalized_checkpoint
+            .epoch
+            .start_slot(T::EthSpec::slots_per_epoch());
+        let new_finalized_state_root = process_results(
+            StateRootsIterator::new(self.store.clone(), &new_head.beacon_state),
+            |mut iter| {
+                iter.find_map(|(state_root, slot)| {
+                    if slot == new_finalized_slot {
+                        Some(state_root)
+                    } else {
+                        None
+                    }
+                })
+            },
+        )?
+        .ok_or_else(|| Error::MissingFinalizedStateRoot(new_finalized_slot))?;

        // It is an error to try to update to a head with a lesser finalized epoch.
-        if new_finalized_epoch < old_finalized_epoch {
+        if new_finalized_checkpoint.epoch < old_finalized_checkpoint.epoch {
            return Err(Error::RevertedFinalizedEpoch {
-                previous_epoch: old_finalized_epoch,
-                new_epoch: new_finalized_epoch,
+                previous_epoch: old_finalized_checkpoint.epoch,
+                new_epoch: new_finalized_checkpoint.epoch,
            });
        }

@@ -1873,11 +1907,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                );
            });

-        if new_finalized_epoch != old_finalized_epoch {
+        if new_finalized_checkpoint.epoch != old_finalized_checkpoint.epoch {
            self.after_finalization(
-                old_finalized_epoch,
-                finalized_root,
-                old_finalized_root.into(),
+                old_finalized_checkpoint,
+                new_finalized_checkpoint,
+                new_finalized_state_root,
            )?;
        }

@@ -1905,68 +1939,53 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
    /// Performs pruning and finality-based optimizations.
    fn after_finalization(
        &self,
-        old_finalized_epoch: Epoch,
-        finalized_block_root: Hash256,
-        old_finalized_root: SignedBeaconBlockHash,
+        old_finalized_checkpoint: Checkpoint,
+        new_finalized_checkpoint: Checkpoint,
+        new_finalized_state_root: Hash256,
    ) -> Result<(), Error> {
-        let finalized_block = self
-            .store
-            .get_block(&finalized_block_root)?
-            .ok_or_else(|| Error::MissingBeaconBlock(finalized_block_root))?
-            .message;
+        self.fork_choice.write().prune()?;

-        let new_finalized_epoch = finalized_block.slot.epoch(T::EthSpec::slots_per_epoch());
+        self.observed_block_producers.prune(
+            new_finalized_checkpoint
+                .epoch
+                .start_slot(T::EthSpec::slots_per_epoch()),
+        );

-        if new_finalized_epoch < old_finalized_epoch {
-            Err(Error::RevertedFinalizedEpoch {
-                previous_epoch: old_finalized_epoch,
-                new_epoch: new_finalized_epoch,
+        self.snapshot_cache
+            .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
+            .map(|mut snapshot_cache| {
+                snapshot_cache.prune(new_finalized_checkpoint.epoch);
            })
-        } else {
-            self.fork_choice.write().prune()?;
-
-            self.observed_block_producers
-                .prune(new_finalized_epoch.start_slot(T::EthSpec::slots_per_epoch()));
-
-            self.snapshot_cache
-                .try_write_for(BLOCK_PROCESSING_CACHE_LOCK_TIMEOUT)
-                .map(|mut snapshot_cache| {
-                    snapshot_cache.prune(new_finalized_epoch);
-                })
-                .unwrap_or_else(|| {
-                    error!(
-                        self.log,
-                        "Failed to obtain cache write lock";
-                        "lock" => "snapshot_cache",
-                        "task" => "prune"
-                    );
-                });
-
-            let finalized_state = self
-                .get_state(&finalized_block.state_root, Some(finalized_block.slot))?
-                .ok_or_else(|| Error::MissingBeaconState(finalized_block.state_root))?;
-
-            self.op_pool
-                .prune_all(&finalized_state, self.head_info()?.fork);
-
-            // TODO: configurable max finality distance
-            let max_finality_distance = 0;
-            self.store_migrator.process_finalization(
-                finalized_block.state_root,
-                finalized_state,
-                max_finality_distance,
-                Arc::clone(&self.head_tracker),
-                old_finalized_root,
-                finalized_block_root.into(),
-            );
-
-            let _ = self.event_handler.register(EventKind::BeaconFinalization {
-                epoch: new_finalized_epoch,
-                root: finalized_block_root,
+            .unwrap_or_else(|| {
+                error!(
+                    self.log,
+                    "Failed to obtain cache write lock";
+                    "lock" => "snapshot_cache",
+                    "task" => "prune"
+                );
            });

-            Ok(())
-        }
+        let finalized_state = self
+            .get_state(&new_finalized_state_root, None)?
+            .ok_or_else(|| Error::MissingBeaconState(new_finalized_state_root))?;
+
+        self.op_pool
+            .prune_all(&finalized_state, self.head_info()?.fork);
+
+        self.store_migrator.process_finalization(
+            new_finalized_state_root.into(),
+            finalized_state,
+            self.head_tracker.clone(),
+            old_finalized_checkpoint,
+            new_finalized_checkpoint,
+        )?;
+
+        let _ = self.event_handler.register(EventKind::BeaconFinalization {
+            epoch: new_finalized_checkpoint.epoch,
+            root: new_finalized_checkpoint.root,
+        });
+
+        Ok(())
    }

    /// Returns `true` if the given block root has not been processed.
@@ -2051,10 +2070,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
            .beacon_block_root;
        let mut visited: HashSet<Hash256> = HashSet::new();
        let mut finalized_blocks: HashSet<Hash256> = HashSet::new();
+        let mut justified_blocks: HashSet<Hash256> = HashSet::new();

        let genesis_block_hash = Hash256::zero();
        writeln!(output, "digraph beacon {{").unwrap();
-        writeln!(output, "\t_{:?}[label=\"genesis\"];", genesis_block_hash).unwrap();
+        writeln!(output, "\t_{:?}[label=\"zero\"];", genesis_block_hash).unwrap();

        // Canonical head needs to be processed first as otherwise finalized blocks aren't detected
        // properly.
@@ -2085,6 +2105,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                        .unwrap()
                        .unwrap();
                    finalized_blocks.insert(state.finalized_checkpoint.root);
+                    justified_blocks.insert(state.current_justified_checkpoint.root);
+                    justified_blocks.insert(state.previous_justified_checkpoint.root);
                }

                if block_hash == canonical_head_hash {
@@ -2105,6 +2127,15 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                        signed_beacon_block.slot()
                    )
                    .unwrap();
+                } else if justified_blocks.contains(&block_hash) {
+                    writeln!(
+                        output,
+                        "\t_{:?}[label=\"{} ({})\" shape=cds];",
+                        block_hash,
+                        block_hash,
+                        signed_beacon_block.slot()
+                    )
+                    .unwrap();
                } else {
                    writeln!(
                        output,
@@ -2134,6 +2165,11 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
        let mut file = std::fs::File::create(file_name).unwrap();
        self.dump_as_dot(&mut file);
    }
+
+    // Should be used in tests only
+    pub fn set_graffiti(&mut self, graffiti: Graffiti) {
+        self.graffiti = graffiti;
+    }
 }

 impl<T: BeaconChainTypes> Drop for BeaconChain<T> {
--- a/beacon_node/beacon_chain/src/errors.rs
+++ b/beacon_node/beacon_chain/src/errors.rs
@@ -1,5 +1,6 @@
 use crate::beacon_chain::ForkChoiceError;
 use crate::eth1_chain::Error as Eth1ChainError;
+use crate::migrate::PruningError;
 use crate::naive_aggregation_pool::Error as NaiveAggregationError;
 use crate::observed_attestations::Error as ObservedAttestationsError;
 use crate::observed_attesters::Error as ObservedAttestersError;
@@ -61,6 +62,7 @@ pub enum BeaconChainError {
        requested_slot: Slot,
        max_task_runtime: Duration,
    },
+    MissingFinalizedStateRoot(Slot),
    /// Returned when an internal check fails, indicating corrupt data.
    InvariantViolated(String),
    SszTypesError(SszTypesError),
@@ -79,6 +81,7 @@ pub enum BeaconChainError {
    ObservedAttestationsError(ObservedAttestationsError),
    ObservedAttestersError(ObservedAttestersError),
    ObservedBlockProducersError(ObservedBlockProducersError),
+    PruningError(PruningError),
    ArithError(ArithError),
 }

@@ -94,6 +97,7 @@ easy_from_to!(ObservedAttestationsError, BeaconChainError);
 easy_from_to!(ObservedAttestersError, BeaconChainError);
 easy_from_to!(ObservedBlockProducersError, BeaconChainError);
 easy_from_to!(BlockSignatureVerifierError, BeaconChainError);
+easy_from_to!(PruningError, BeaconChainError);
 easy_from_to!(ArithError, BeaconChainError);

 #[derive(Debug)]
--- a/beacon_node/beacon_chain/src/lib.rs
+++ b/beacon_node/beacon_chain/src/lib.rs
@@ -2,6 +2,10 @@
 #[macro_use]
 extern crate lazy_static;

+#[macro_use]
+extern crate slog;
+extern crate slog_term;
+
 pub mod attestation_verification;
 mod beacon_chain;
 mod beacon_fork_choice_store;
--- a/beacon_node/beacon_chain/src/migrate.rs
+++ b/beacon_node/beacon_chain/src/migrate.rs
@@ -7,12 +7,28 @@ use std::mem;
 use std::sync::mpsc;
 use std::sync::Arc;
 use std::thread;
-use store::hot_cold_store::{process_finalization, HotColdDBError};
-use store::iter::{ParentRootBlockIterator, RootsIterator};
+use store::hot_cold_store::{migrate_database, HotColdDBError};
+use store::iter::RootsIterator;
 use store::{Error, ItemStore, StoreOp};
 pub use store::{HotColdDB, MemoryStore};
-use types::*;
-use types::{BeaconState, EthSpec, Hash256, Slot};
+use types::{
+    BeaconState, BeaconStateError, BeaconStateHash, Checkpoint, EthSpec, Hash256,
+    SignedBeaconBlockHash, Slot,
+};
+
+/// Logic errors that can occur during pruning, none of these should ever happen.
+#[derive(Debug)]
+pub enum PruningError {
+    IncorrectFinalizedState {
+        state_slot: Slot,
+        new_finalized_slot: Slot,
+    },
+    MissingInfoForCanonicalChain {
+        slot: Slot,
+    },
+    UnexpectedEqualStateRoots,
+    UnexpectedUnequalStateRoots,
+}

 /// Trait for migration processes that update the database upon finalization.
 pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
@@ -22,17 +38,17 @@ pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:

    fn process_finalization(
        &self,
-        _state_root: Hash256,
+        _finalized_state_root: BeaconStateHash,
        _new_finalized_state: BeaconState<E>,
-        _max_finality_distance: u64,
        _head_tracker: Arc<HeadTracker>,
-        _old_finalized_block_hash: SignedBeaconBlockHash,
-        _new_finalized_block_hash: SignedBeaconBlockHash,
-    ) {
+        _old_finalized_checkpoint: Checkpoint,
+        _new_finalized_checkpoint: Checkpoint,
+    ) -> Result<(), BeaconChainError> {
+        Ok(())
    }

    /// Traverses live heads and prunes blocks and states of chains that we know can't be built
-    /// upon because finalization would prohibit it.  This is an optimisation intended to save disk
+    /// upon because finalization would prohibit it. This is an optimisation intended to save disk
    /// space.
    ///
    /// Assumptions:
@@ -40,37 +56,63 @@ pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
    fn prune_abandoned_forks(
        store: Arc<HotColdDB<E, Hot, Cold>>,
        head_tracker: Arc<HeadTracker>,
-        old_finalized_block_hash: SignedBeaconBlockHash,
-        new_finalized_block_hash: SignedBeaconBlockHash,
-        new_finalized_slot: Slot,
+        new_finalized_state_hash: BeaconStateHash,
+        new_finalized_state: &BeaconState<E>,
+        old_finalized_checkpoint: Checkpoint,
+        new_finalized_checkpoint: Checkpoint,
+        log: &Logger,
    ) -> Result<(), BeaconChainError> {
        // There will never be any blocks to prune if there is only a single head in the chain.
        if head_tracker.heads().len() == 1 {
            return Ok(());
        }

-        let old_finalized_slot = store
-            .get_block(&old_finalized_block_hash.into())?
-            .ok_or_else(|| BeaconChainError::MissingBeaconBlock(old_finalized_block_hash.into()))?
-            .slot();
+        let old_finalized_slot = old_finalized_checkpoint
+            .epoch
+            .start_slot(E::slots_per_epoch());
+        let new_finalized_slot = new_finalized_checkpoint
+            .epoch
+            .start_slot(E::slots_per_epoch());
+        let new_finalized_block_hash = new_finalized_checkpoint.root.into();

-        // Collect hashes from new_finalized_block back to old_finalized_block (inclusive)
-        let mut found_block = false; // hack for `take_until`
-        let newly_finalized_blocks: HashMap<SignedBeaconBlockHash, Slot> =
-            ParentRootBlockIterator::new(&*store, new_finalized_block_hash.into())
-                .take_while(|result| match result {
-                    Ok((block_hash, _)) => {
-                        if found_block {
-                            false
-                        } else {
-                            found_block |= *block_hash == old_finalized_block_hash.into();
-                            true
-                        }
-                    }
-                    Err(_) => true,
-                })
-                .map(|result| result.map(|(block_hash, block)| (block_hash.into(), block.slot())))
-                .collect::<Result<_, _>>()?;
+        // The finalized state must be for the epoch boundary slot, not the slot of the finalized
+        // block.
+        if new_finalized_state.slot != new_finalized_slot {
+            return Err(PruningError::IncorrectFinalizedState {
+                state_slot: new_finalized_state.slot,
+                new_finalized_slot,
+            }
+            .into());
+        }
+
+        debug!(
+            log,
+            "Starting database pruning";
+            "old_finalized_epoch" => old_finalized_checkpoint.epoch,
+            "old_finalized_root" => format!("{:?}", old_finalized_checkpoint.root),
+            "new_finalized_epoch" => new_finalized_checkpoint.epoch,
+            "new_finalized_root" => format!("{:?}", new_finalized_checkpoint.root),
+        );
+
+        // For each slot between the new finalized checkpoint and the old finalized checkpoint,
+        // collect the beacon block root and state root of the canonical chain.
+        let newly_finalized_chain: HashMap<Slot, (SignedBeaconBlockHash, BeaconStateHash)> =
+            std::iter::once(Ok((
+                new_finalized_slot,
+                (new_finalized_block_hash, new_finalized_state_hash),
+            )))
+            .chain(
+                RootsIterator::new(store.clone(), new_finalized_state).map(|res| {
+                    res.map(|(block_root, state_root, slot)| {
+                        (slot, (block_root.into(), state_root.into()))
+                    })
+                }),
+            )
+            .take_while(|res| {
+                res.as_ref()
+                    .map_or(true, |(slot, _)| *slot >= old_finalized_slot)
+            })
+            .collect::<Result<_, _>>()?;

        // We don't know which blocks are shared among abandoned chains, so we buffer and delete
        // everything in one fell swoop.
@@ -79,75 +121,110 @@ pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
        let mut abandoned_heads: HashSet<Hash256> = HashSet::new();

        for (head_hash, head_slot) in head_tracker.heads() {
-            let mut potentially_abandoned_head: Option<Hash256> = Some(head_hash);
-            let mut potentially_abandoned_blocks: Vec<(
-                Slot,
-                Option<SignedBeaconBlockHash>,
-                Option<BeaconStateHash>,
-            )> = Vec::new();
+            let mut potentially_abandoned_head = Some(head_hash);
+            let mut potentially_abandoned_blocks = vec![];

            let head_state_hash = store
                .get_block(&head_hash)?
                .ok_or_else(|| BeaconStateError::MissingBeaconBlock(head_hash.into()))?
                .state_root();

+            // Iterate backwards from this head, staging blocks and states for deletion.
            let iter = std::iter::once(Ok((head_hash, head_state_hash, head_slot)))
-                .chain(RootsIterator::from_block(Arc::clone(&store), head_hash)?);
+                .chain(RootsIterator::from_block(store.clone(), head_hash)?);
+
            for maybe_tuple in iter {
-                let (block_hash, state_hash, slot) = maybe_tuple?;
-                if slot < old_finalized_slot {
-                    // We must assume here any candidate chains include old_finalized_block_hash,
-                    // i.e. there aren't any forks starting at a block that is a strict ancestor of
-                    // old_finalized_block_hash.
-                    break;
-                }
-                match newly_finalized_blocks.get(&block_hash.into()).copied() {
-                    // Block is not finalized, mark it and its state for deletion
+                let (block_root, state_root, slot) = maybe_tuple?;
+                let block_root = SignedBeaconBlockHash::from(block_root);
+                let state_root = BeaconStateHash::from(state_root);
+
+                match newly_finalized_chain.get(&slot) {
+                    // If there's no information about a slot on the finalized chain, then
+                    // it should be because it's ahead of the new finalized slot. Stage
+                    // the fork's block and state for possible deletion.
                    None => {
-                        potentially_abandoned_blocks.push((
-                            slot,
-                            Some(block_hash.into()),
-                            Some(state_hash.into()),
-                        ));
+                        if slot > new_finalized_slot {
+                            potentially_abandoned_blocks.push((
+                                slot,
+                                Some(block_root),
+                                Some(state_root),
+                            ));
+                        } else if slot >= old_finalized_slot {
+                            return Err(PruningError::MissingInfoForCanonicalChain { slot }.into());
+                        } else {
+                            // We must assume here any candidate chains include the old finalized
+                            // checkpoint, i.e. there aren't any forks starting at a block that is a
+                            // strict ancestor of old_finalized_checkpoint.
+                            warn!(
+                                log,
+                                "Found a chain that should already have been pruned";
+                                "head_block_root" => format!("{:?}", head_hash),
+                                "head_slot" => head_slot,
+                            );
+                            break;
+                        }
                    }
-                    Some(finalized_slot) => {
-                        // Block root is finalized, and we have reached the slot it was finalized
-                        // at: we've hit a shared part of the chain.
-                        if finalized_slot == slot {
-                            // The first finalized block of a candidate chain lies after (in terms
-                            // of slots order) the newly finalized block.  It's not a candidate for
-                            // prunning.
-                            if finalized_slot == new_finalized_slot {
+                    Some((finalized_block_root, finalized_state_root)) => {
+                        // This fork descends from a newly finalized block, we can stop.
+                        if block_root == *finalized_block_root {
+                            // Sanity check: if the slot and block root match, then the
+                            // state roots should match too.
+                            if state_root != *finalized_state_root {
+                                return Err(PruningError::UnexpectedUnequalStateRoots.into());
+                            }
+
+                            // If the fork descends from the whole finalized chain,
+                            // do not prune it. Otherwise continue to delete all
+                            // of the blocks and states that have been staged for
+                            // deletion so far.
+                            if slot == new_finalized_slot {
                                potentially_abandoned_blocks.clear();
                                potentially_abandoned_head.take();
                            }
-
+                            // If there are skipped slots on the fork to be pruned, then
+                            // we will have just staged the common block for deletion.
+                            // Unstage it.
+                            else {
+                                for (_, block_root, _) in
+                                    potentially_abandoned_blocks.iter_mut().rev()
+                                {
+                                    if block_root.as_ref() == Some(finalized_block_root) {
+                                        *block_root = None;
+                                    } else {
+                                        break;
+                                    }
+                                }
+                            }
                            break;
-                        }
-                        // Block root is finalized, but we're at a skip slot: delete the state only.
-                        else {
+                        } else {
+                            if state_root == *finalized_state_root {
+                                return Err(PruningError::UnexpectedEqualStateRoots.into());
+                            }
                            potentially_abandoned_blocks.push((
                                slot,
-                                None,
-                                Some(state_hash.into()),
+                                Some(block_root),
+                                Some(state_root),
                            ));
                        }
                    }
                }
            }

-            abandoned_heads.extend(potentially_abandoned_head.into_iter());
-            if !potentially_abandoned_blocks.is_empty() {
+            if let Some(abandoned_head) = potentially_abandoned_head {
+                debug!(
+                    log,
+                    "Pruning head";
+                    "head_block_root" => format!("{:?}", abandoned_head),
+                    "head_slot" => head_slot,
+                );
+                abandoned_heads.insert(abandoned_head);
                abandoned_blocks.extend(
                    potentially_abandoned_blocks
                        .iter()
                        .filter_map(|(_, maybe_block_hash, _)| *maybe_block_hash),
                );
                abandoned_states.extend(potentially_abandoned_blocks.iter().filter_map(
-                    |(slot, _, maybe_state_hash)| match maybe_state_hash {
-                        None => None,
-                        Some(state_hash) => Some((*slot, *state_hash)),
-                    },
+                    |(slot, _, maybe_state_hash)| maybe_state_hash.map(|sr| (*slot, sr)),
                ));
            }
        }
@@ -161,11 +238,14 @@ pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
                    .map(|(slot, state_hash)| StoreOp::DeleteState(state_hash, slot)),
            )
            .collect();
+
        store.do_atomically(batch)?;
        for head_hash in abandoned_heads.into_iter() {
            head_tracker.remove_head(head_hash);
        }

+        debug!(log, "Database pruning complete");
+
        Ok(())
    }
 }
@@ -174,6 +254,17 @@ pub trait Migrate<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>:
 pub struct NullMigrator;

 impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold> for NullMigrator {
+    fn process_finalization(
+        &self,
+        _finalized_state_root: BeaconStateHash,
+        _new_finalized_state: BeaconState<E>,
+        _head_tracker: Arc<HeadTracker>,
+        _old_finalized_checkpoint: Checkpoint,
+        _new_finalized_checkpoint: Checkpoint,
+    ) -> Result<(), BeaconChainError> {
+        Ok(())
+    }
+
    fn new(_: Arc<HotColdDB<E, Hot, Cold>>, _: Logger) -> Self {
        NullMigrator
    }
@@ -184,48 +275,59 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold> fo
 /// Mostly useful for tests.
 pub struct BlockingMigrator<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> {
    db: Arc<HotColdDB<E, Hot, Cold>>,
+    log: Logger,
 }

 impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold>
    for BlockingMigrator<E, Hot, Cold>
 {
-    fn new(db: Arc<HotColdDB<E, Hot, Cold>>, _: Logger) -> Self {
-        BlockingMigrator { db }
+    fn new(db: Arc<HotColdDB<E, Hot, Cold>>, log: Logger) -> Self {
+        BlockingMigrator { db, log }
    }

    fn process_finalization(
        &self,
-        state_root: Hash256,
+        finalized_state_root: BeaconStateHash,
        new_finalized_state: BeaconState<E>,
-        _max_finality_distance: u64,
        head_tracker: Arc<HeadTracker>,
-        old_finalized_block_hash: SignedBeaconBlockHash,
-        new_finalized_block_hash: SignedBeaconBlockHash,
-    ) {
-        if let Err(e) = Self::prune_abandoned_forks(
+        old_finalized_checkpoint: Checkpoint,
+        new_finalized_checkpoint: Checkpoint,
+    ) -> Result<(), BeaconChainError> {
+        Self::prune_abandoned_forks(
            self.db.clone(),
            head_tracker,
-            old_finalized_block_hash,
-            new_finalized_block_hash,
-            new_finalized_state.slot,
-        ) {
-            eprintln!("Pruning error: {:?}", e);
-        }
+            finalized_state_root,
+            &new_finalized_state,
+            old_finalized_checkpoint,
+            new_finalized_checkpoint,
+            &self.log,
+        )?;

-        if let Err(e) = process_finalization(self.db.clone(), state_root, &new_finalized_state) {
-            // This migrator is only used for testing, so we just log to stderr without a logger.
-            eprintln!("Migration error: {:?}", e);
+        match migrate_database(
+            self.db.clone(),
+            finalized_state_root.into(),
+            &new_finalized_state,
+        ) {
+            Ok(()) => Ok(()),
+            Err(Error::HotColdDBError(HotColdDBError::FreezeSlotUnaligned(slot))) => {
+                debug!(
+                    self.log,
+                    "Database migration postponed, unaligned finalized block";
+                    "slot" => slot.as_u64()
+                );
+                Ok(())
+            }
+            Err(e) => Err(e.into()),
        }
    }
 }

 type MpscSender<E> = mpsc::Sender<(
-    Hash256,
+    BeaconStateHash,
    BeaconState<E>,
    Arc<HeadTracker>,
-    SignedBeaconBlockHash,
-    SignedBeaconBlockHash,
-    Slot,
+    Checkpoint,
+    Checkpoint,
 )>;

 /// Migrator that runs a background thread to migrate state from the hot to the cold database.
@@ -243,34 +345,26 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold>
        Self { db, tx_thread, log }
    }

-    /// Perform the freezing operation on the database,
    fn process_finalization(
        &self,
-        finalized_state_root: Hash256,
+        finalized_state_root: BeaconStateHash,
        new_finalized_state: BeaconState<E>,
-        max_finality_distance: u64,
        head_tracker: Arc<HeadTracker>,
-        old_finalized_block_hash: SignedBeaconBlockHash,
-        new_finalized_block_hash: SignedBeaconBlockHash,
-    ) {
-        if !self.needs_migration(new_finalized_state.slot, max_finality_distance) {
-            return;
-        }
-
+        old_finalized_checkpoint: Checkpoint,
+        new_finalized_checkpoint: Checkpoint,
+    ) -> Result<(), BeaconChainError> {
        let (ref mut tx, ref mut thread) = *self.tx_thread.lock();

-        let new_finalized_slot = new_finalized_state.slot;
        if let Err(tx_err) = tx.send((
            finalized_state_root,
            new_finalized_state,
            head_tracker,
-            old_finalized_block_hash,
-            new_finalized_block_hash,
-            new_finalized_slot,
+            old_finalized_checkpoint,
+            new_finalized_checkpoint,
        )) {
            let (new_tx, new_thread) = Self::spawn_thread(self.db.clone(), self.log.clone());

-            drop(mem::replace(tx, new_tx));
+            *tx = new_tx;
            let old_thread = mem::replace(thread, new_thread);

            // Join the old thread, which will probably have panicked, or may have
@@ -286,57 +380,43 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> Migrate<E, Hot, Cold>
            // Retry at most once, we could recurse but that would risk overflowing the stack.
            let _ = tx.send(tx_err.0);
        }
+
+        Ok(())
    }
 }

 impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> BackgroundMigrator<E, Hot, Cold> {
-    /// Return true if a migration needs to be performed, given a new `finalized_slot`.
-    fn needs_migration(&self, finalized_slot: Slot, max_finality_distance: u64) -> bool {
-        let finality_distance = finalized_slot - self.db.get_split_slot();
-        finality_distance > max_finality_distance
-    }
-
-    #[allow(clippy::type_complexity)]
    /// Spawn a new child thread to run the migration process.
    ///
    /// Return a channel handle for sending new finalized states to the thread.
    fn spawn_thread(
        db: Arc<HotColdDB<E, Hot, Cold>>,
        log: Logger,
-    ) -> (
-        mpsc::Sender<(
-            Hash256,
-            BeaconState<E>,
-            Arc<HeadTracker>,
-            SignedBeaconBlockHash,
-            SignedBeaconBlockHash,
-            Slot,
-        )>,
-        thread::JoinHandle<()>,
-    ) {
+    ) -> (MpscSender<E>, thread::JoinHandle<()>) {
        let (tx, rx) = mpsc::channel();
        let thread = thread::spawn(move || {
            while let Ok((
                state_root,
                state,
                head_tracker,
-                old_finalized_block_hash,
-                new_finalized_block_hash,
-                new_finalized_slot,
+                old_finalized_checkpoint,
+                new_finalized_checkpoint,
            )) = rx.recv()
            {
                match Self::prune_abandoned_forks(
                    db.clone(),
                    head_tracker,
-                    old_finalized_block_hash,
-                    new_finalized_block_hash,
-                    new_finalized_slot,
+                    state_root,
+                    &state,
+                    old_finalized_checkpoint,
+                    new_finalized_checkpoint,
+                    &log,
                ) {
                    Ok(()) => {}
                    Err(e) => warn!(log, "Block pruning failed: {:?}", e),
                }

-                match process_finalization(db.clone(), state_root, &state) {
+                match migrate_database(db.clone(), state_root.into(), &state) {
                    Ok(()) => {}
                    Err(Error::HotColdDBError(HotColdDBError::FreezeSlotUnaligned(slot))) => {
                        debug!(
--- a/beacon_node/beacon_chain/src/test_utils.rs
+++ b/beacon_node/beacon_chain/src/test_utils.rs
--- a/beacon_node/beacon_chain/tests/attestation_production.rs
+++ b/beacon_node/beacon_chain/tests/attestation_production.rs
@@ -26,7 +26,7 @@ lazy_static! {
 fn produces_attestations() {
    let num_blocks_produced = MainnetEthSpec::slots_per_epoch() * 4;

-    let harness = BeaconChainHarness::new(
+    let mut harness = BeaconChainHarness::new_with_store_config(
        MainnetEthSpec,
        KEYPAIRS[..].to_vec(),
        StoreConfig::default(),
--- a/beacon_node/beacon_chain/tests/attestation_verification.rs
+++ b/beacon_node/beacon_chain/tests/attestation_verification.rs
@@ -5,7 +5,9 @@ extern crate lazy_static;

 use beacon_chain::{
    attestation_verification::Error as AttnError,
-    test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, HarnessType},
+    test_utils::{
+        AttestationStrategy, BeaconChainHarness, BlockStrategy, NullMigratorEphemeralHarnessType,
+    },
    BeaconChain, BeaconChainTypes,
 };
 use int_to_bytes::int_to_bytes32;
@@ -30,7 +32,7 @@ lazy_static! {
 }

 /// Returns a beacon chain harness.
-fn get_harness(validator_count: usize) -> BeaconChainHarness<HarnessType<E>> {
+fn get_harness(validator_count: usize) -> BeaconChainHarness<NullMigratorEphemeralHarnessType<E>> {
    let harness = BeaconChainHarness::new_with_target_aggregators(
        MainnetEthSpec,
        KEYPAIRS[0..validator_count].to_vec(),
@@ -184,8 +186,7 @@ fn get_non_aggregator<T: BeaconChainTypes>(
 /// Tests verification of `SignedAggregateAndProof` from the gossip network.
 #[test]
 fn aggregated_gossip_verification() {
-    let harness = get_harness(VALIDATOR_COUNT);
-    let chain = &harness.chain;
+    let mut harness = get_harness(VALIDATOR_COUNT);

    // Extend the chain out a few epochs so we have some chain depth to play with.
    harness.extend_chain(
@@ -197,7 +198,7 @@ fn aggregated_gossip_verification() {
    // Advance into a slot where there have not been blocks or attestations produced.
    harness.advance_slot();

-    let current_slot = chain.slot().expect("should get slot");
+    let current_slot = harness.chain.slot().expect("should get slot");

    assert_eq!(
        current_slot % E::slots_per_epoch(),
@@ -532,8 +533,7 @@ fn aggregated_gossip_verification() {
 /// Tests the verification conditions for an unaggregated attestation on the gossip network.
 #[test]
 fn unaggregated_gossip_verification() {
-    let harness = get_harness(VALIDATOR_COUNT);
-    let chain = &harness.chain;
+    let mut harness = get_harness(VALIDATOR_COUNT);

    // Extend the chain out a few epochs so we have some chain depth to play with.
    harness.extend_chain(
@@ -545,8 +545,8 @@ fn unaggregated_gossip_verification() {
    // Advance into a slot where there have not been blocks or attestations produced.
    harness.advance_slot();

-    let current_slot = chain.slot().expect("should get slot");
-    let current_epoch = chain.epoch().expect("should get epoch");
+    let current_slot = harness.chain.slot().expect("should get slot");
+    let current_epoch = harness.chain.epoch().expect("should get epoch");

    assert_eq!(
        current_slot % E::slots_per_epoch(),
@@ -772,8 +772,7 @@ fn unaggregated_gossip_verification() {
 /// This also checks that we can do a state lookup if we don't get a hit from the shuffling cache.
 #[test]
 fn attestation_that_skips_epochs() {
-    let harness = get_harness(VALIDATOR_COUNT);
-    let chain = &harness.chain;
+    let mut harness = get_harness(VALIDATOR_COUNT);

    // Extend the chain out a few epochs so we have some chain depth to play with.
    harness.extend_chain(
@@ -782,16 +781,18 @@ fn attestation_that_skips_epochs() {
        AttestationStrategy::SomeValidators(vec![]),
    );

-    let current_slot = chain.slot().expect("should get slot");
-    let current_epoch = chain.epoch().expect("should get epoch");
+    let current_slot = harness.chain.slot().expect("should get slot");
+    let current_epoch = harness.chain.epoch().expect("should get epoch");

    let earlier_slot = (current_epoch - 2).start_slot(MainnetEthSpec::slots_per_epoch());
-    let earlier_block = chain
+    let earlier_block = harness
+        .chain
        .block_at_slot(earlier_slot)
        .expect("should not error getting block at slot")
        .expect("should find block at slot");

-    let mut state = chain
+    let mut state = harness
+        .chain
        .get_state(&earlier_block.state_root(), Some(earlier_slot))
        .expect("should not error getting state")
        .expect("should find state");
--- a/beacon_node/beacon_chain/tests/block_verification.rs
+++ b/beacon_node/beacon_chain/tests/block_verification.rs
@@ -4,7 +4,9 @@
 extern crate lazy_static;

 use beacon_chain::{
-    test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, HarnessType},
+    test_utils::{
+        AttestationStrategy, BeaconChainHarness, BlockStrategy, NullMigratorEphemeralHarnessType,
+    },
    BeaconSnapshot, BlockError,
 };
 use store::config::StoreConfig;
@@ -31,7 +33,7 @@ lazy_static! {
 }

 fn get_chain_segment() -> Vec<BeaconSnapshot<E>> {
-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        CHAIN_SEGMENT_LENGTH,
@@ -48,8 +50,8 @@ fn get_chain_segment() -> Vec<BeaconSnapshot<E>> {
        .collect()
 }

-fn get_harness(validator_count: usize) -> BeaconChainHarness<HarnessType<E>> {
-    let harness = BeaconChainHarness::new(
+fn get_harness(validator_count: usize) -> BeaconChainHarness<NullMigratorEphemeralHarnessType<E>> {
+    let harness = BeaconChainHarness::new_with_store_config(
        MainnetEthSpec,
        KEYPAIRS[0..validator_count].to_vec(),
        StoreConfig::default(),
@@ -81,7 +83,7 @@ fn junk_aggregate_signature() -> AggregateSignature {

 fn update_proposal_signatures(
    snapshots: &mut [BeaconSnapshot<E>],
-    harness: &BeaconChainHarness<HarnessType<E>>,
+    harness: &BeaconChainHarness<NullMigratorEphemeralHarnessType<E>>,
 ) {
    for snapshot in snapshots {
        let spec = &harness.chain.spec;
@@ -91,7 +93,7 @@ fn update_proposal_signatures(
            .get_beacon_proposer_index(slot, spec)
            .expect("should find proposer index");
        let keypair = harness
-            .keypairs
+            .validators_keypairs
            .get(proposer_index)
            .expect("proposer keypair should be available");

@@ -274,7 +276,7 @@ fn chain_segment_non_linear_slots() {
 }

 fn assert_invalid_signature(
-    harness: &BeaconChainHarness<HarnessType<E>>,
+    harness: &BeaconChainHarness<NullMigratorEphemeralHarnessType<E>>,
    block_index: usize,
    snapshots: &[BeaconSnapshot<E>],
    item: &str,
@@ -325,7 +327,7 @@ fn assert_invalid_signature(
    // slot) tuple.
 }

-fn get_invalid_sigs_harness() -> BeaconChainHarness<HarnessType<E>> {
+fn get_invalid_sigs_harness() -> BeaconChainHarness<NullMigratorEphemeralHarnessType<E>> {
    let harness = get_harness(VALIDATOR_COUNT);
    harness
        .chain
--- a/beacon_node/beacon_chain/tests/op_verification.rs
+++ b/beacon_node/beacon_chain/tests/op_verification.rs
@@ -7,7 +7,7 @@ extern crate lazy_static;

 use beacon_chain::observed_operations::ObservationOutcome;
 use beacon_chain::test_utils::{
-    AttestationStrategy, BeaconChainHarness, BlockStrategy, DiskHarnessType,
+    AttestationStrategy, BeaconChainHarness, BlockStrategy, BlockingMigratorDiskHarnessType,
 };
 use sloggers::{null::NullLoggerBuilder, Build};
 use std::sync::Arc;
@@ -28,7 +28,7 @@ lazy_static! {
 }

 type E = MinimalEthSpec;
-type TestHarness = BeaconChainHarness<DiskHarnessType<E>>;
+type TestHarness = BeaconChainHarness<BlockingMigratorDiskHarnessType<E>>;
 type HotColdDB = store::HotColdDB<E, LevelDB<E>, LevelDB<E>>;

 fn get_store(db_path: &TempDir) -> Arc<HotColdDB> {
@@ -57,8 +57,8 @@ fn get_harness(store: Arc<HotColdDB>, validator_count: usize) -> TestHarness {
 fn voluntary_exit() {
    let db_path = tempdir().unwrap();
    let store = get_store(&db_path);
-    let harness = get_harness(store.clone(), VALIDATOR_COUNT);
-    let spec = &harness.chain.spec;
+    let mut harness = get_harness(store.clone(), VALIDATOR_COUNT);
+    let spec = &harness.chain.spec.clone();

    harness.extend_chain(
        (E::slots_per_epoch() * (spec.shard_committee_period + 1)) as usize,
--- a/beacon_node/beacon_chain/tests/persistence_tests.rs
+++ b/beacon_node/beacon_chain/tests/persistence_tests.rs
@@ -44,7 +44,7 @@ fn finalizes_after_resuming_from_db() {
    let db_path = tempdir().unwrap();
    let store = get_store(&db_path);

-    let harness = BeaconChainHarness::new_with_disk_store(
+    let mut harness = BeaconChainHarness::new_with_disk_store(
        MinimalEthSpec,
        store.clone(),
        KEYPAIRS[0..validator_count].to_vec(),
@@ -88,7 +88,7 @@ fn finalizes_after_resuming_from_db() {
    let data_dir = harness.data_dir;
    let original_chain = harness.chain;

-    let resumed_harness = BeaconChainHarness::resume_from_disk_store(
+    let mut resumed_harness = BeaconChainHarness::resume_from_disk_store(
        MinimalEthSpec,
        store,
        KEYPAIRS[0..validator_count].to_vec(),
--- a/beacon_node/beacon_chain/tests/store_tests.rs
+++ b/beacon_node/beacon_chain/tests/store_tests.rs
--- a/beacon_node/beacon_chain/tests/tests.rs
+++ b/beacon_node/beacon_chain/tests/tests.rs
@@ -6,7 +6,8 @@ extern crate lazy_static;
 use beacon_chain::{
    attestation_verification::Error as AttnError,
    test_utils::{
-        AttestationStrategy, BeaconChainHarness, BlockStrategy, HarnessType, OP_POOL_DB_KEY,
+        AttestationStrategy, BeaconChainHarness, BlockStrategy, NullMigratorEphemeralHarnessType,
+        OP_POOL_DB_KEY,
    },
 };
 use operation_pool::PersistedOperationPool;
@@ -24,8 +25,10 @@ lazy_static! {
    static ref KEYPAIRS: Vec<Keypair> = types::test_utils::generate_deterministic_keypairs(VALIDATOR_COUNT);
 }

-fn get_harness(validator_count: usize) -> BeaconChainHarness<HarnessType<MinimalEthSpec>> {
-    let harness = BeaconChainHarness::new(
+fn get_harness(
+    validator_count: usize,
+) -> BeaconChainHarness<NullMigratorEphemeralHarnessType<MinimalEthSpec>> {
+    let harness = BeaconChainHarness::new_with_store_config(
        MinimalEthSpec,
        KEYPAIRS[0..validator_count].to_vec(),
        StoreConfig::default(),
@@ -64,7 +67,7 @@ fn massive_skips() {
 fn iterators() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 2 - 1;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        num_blocks_produced as usize,
@@ -139,7 +142,7 @@ fn iterators() {

 #[test]
 fn chooses_fork() {
-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    let two_thirds = (VALIDATOR_COUNT / 3) * 2;
    let delay = MinimalEthSpec::default_spec().min_attestation_inclusion_delay as usize;
@@ -190,7 +193,7 @@ fn chooses_fork() {
 fn finalizes_with_full_participation() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        num_blocks_produced as usize,
@@ -225,7 +228,7 @@ fn finalizes_with_full_participation() {
 fn finalizes_with_two_thirds_participation() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    let two_thirds = (VALIDATOR_COUNT / 3) * 2;
    let attesters = (0..two_thirds).collect();
@@ -268,7 +271,7 @@ fn finalizes_with_two_thirds_participation() {
 fn does_not_finalize_with_less_than_two_thirds_participation() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    let two_thirds = (VALIDATOR_COUNT / 3) * 2;
    let less_than_two_thirds = two_thirds - 1;
@@ -305,7 +308,7 @@ fn does_not_finalize_with_less_than_two_thirds_participation() {
 fn does_not_finalize_without_attestation() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        num_blocks_produced as usize,
@@ -338,7 +341,7 @@ fn does_not_finalize_without_attestation() {
 fn roundtrip_operation_pool() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    // Add some attestations
    harness.extend_chain(
@@ -370,7 +373,7 @@ fn roundtrip_operation_pool() {
 fn unaggregated_attestations_added_to_fork_choice_some_none() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() / 2;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        num_blocks_produced as usize,
@@ -424,7 +427,7 @@ fn unaggregated_attestations_added_to_fork_choice_some_none() {
 fn attestations_with_increasing_slots() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 5;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    let mut attestations = vec![];

@@ -486,7 +489,7 @@ fn attestations_with_increasing_slots() {
 fn unaggregated_attestations_added_to_fork_choice_all_updated() {
    let num_blocks_produced = MinimalEthSpec::slots_per_epoch() * 2 - 1;

-    let harness = get_harness(VALIDATOR_COUNT);
+    let mut harness = get_harness(VALIDATOR_COUNT);

    harness.extend_chain(
        num_blocks_produced as usize,
@@ -541,7 +544,7 @@ fn unaggregated_attestations_added_to_fork_choice_all_updated() {

 fn run_skip_slot_test(skip_slots: u64) {
    let num_validators = 8;
-    let harness_a = get_harness(num_validators);
+    let mut harness_a = get_harness(num_validators);
    let harness_b = get_harness(num_validators);

    for _ in 0..skip_slots {
--- a/beacon_node/eth2_libp2p/src/discovery/enr.rs
+++ b/beacon_node/eth2_libp2p/src/discovery/enr.rs
@@ -6,6 +6,7 @@ use super::enr_ext::CombinedKeyExt;
 use super::ENR_FILENAME;
 use crate::types::{Enr, EnrBitfield};
 use crate::NetworkConfig;
+use discv5::enr::EnrKey;
 use libp2p::core::identity::Keypair;
 use slog::{debug, warn};
 use ssz::{Decode, Encode};
@@ -48,6 +49,56 @@ impl Eth2Enr for Enr {
    }
 }

+/// Either use the given ENR or load an ENR from file if it exists and matches the current NodeId
+/// and sequence number.
+/// If an ENR exists, with the same NodeId, this function checks to see if the loaded ENR from
+/// disk is suitable to use, otherwise we increment the given ENR's sequence number.
+pub fn use_or_load_enr(
+    enr_key: &CombinedKey,
+    local_enr: &mut Enr,
+    config: &NetworkConfig,
+    log: &slog::Logger,
+) -> Result<(), String> {
+    let enr_f = config.network_dir.join(ENR_FILENAME);
+    if let Ok(mut enr_file) = File::open(enr_f.clone()) {
+        let mut enr_string = String::new();
+        match enr_file.read_to_string(&mut enr_string) {
+            Err(_) => debug!(log, "Could not read ENR from file"),
+            Ok(_) => {
+                match Enr::from_str(&enr_string) {
+                    Ok(disk_enr) => {
+                        // if the same node id, then we may need to update our sequence number
+                        if local_enr.node_id() == disk_enr.node_id() {
+                            if compare_enr(&local_enr, &disk_enr) {
+                                debug!(log, "ENR loaded from disk"; "file" => format!("{:?}", enr_f));
+                                // the stored ENR has the same configuration, use it
+                                *local_enr = disk_enr;
+                                return Ok(());
+                            }
+
+                            // same node id, different configuration - update the sequence number
+                            // Note: local_enr is generated with default(0) attnets value,
+                            // so a non default value in persisted enr will also update sequence number.
+                            let new_seq_no = disk_enr.seq().checked_add(1).ok_or_else(|| "ENR sequence number on file is too large. Remove it to generate a new NodeId")?;
+                            local_enr.set_seq(new_seq_no, enr_key).map_err(|e| {
+                                format!("Could not update ENR sequence number: {:?}", e)
+                            })?;
+                            debug!(log, "ENR sequence number increased"; "seq" =>  new_seq_no);
+                        }
+                    }
+                    Err(e) => {
+                        warn!(log, "ENR from file could not be decoded"; "error" => format!("{:?}", e));
+                    }
+                }
+            }
+        }
+    }
+
+    save_enr_to_disk(&config.network_dir, &local_enr, log);
+
+    Ok(())
+}
+
 /// Loads an ENR from file if it exists and matches the current NodeId and sequence number. If none
 /// exists, generates a new one.
 ///
@@ -65,51 +116,11 @@ pub fn build_or_load_enr<T: EthSpec>(
    let enr_key = CombinedKey::from_libp2p(&local_key)?;
    let mut local_enr = build_enr::<T>(&enr_key, config, enr_fork_id)?;

-    let enr_f = config.network_dir.join(ENR_FILENAME);
-    if let Ok(mut enr_file) = File::open(enr_f.clone()) {
-        let mut enr_string = String::new();
-        match enr_file.read_to_string(&mut enr_string) {
-            Err(_) => debug!(log, "Could not read ENR from file"),
-            Ok(_) => {
-                match Enr::from_str(&enr_string) {
-                    Ok(disk_enr) => {
-                        // if the same node id, then we may need to update our sequence number
-                        if local_enr.node_id() == disk_enr.node_id() {
-                            if compare_enr(&local_enr, &disk_enr) {
-                                debug!(log, "ENR loaded from disk"; "file" => format!("{:?}", enr_f));
-                                // the stored ENR has the same configuration, use it
-                                return Ok(disk_enr);
-                            }
-
-                            // same node id, different configuration - update the sequence number
-                            // Note: local_enr is generated with default(0) attnets value,
-                            // so a non default value in persisted enr will also update sequence number.
-                            let new_seq_no = disk_enr.seq().checked_add(1).ok_or_else(|| "ENR sequence number on file is too large. Remove it to generate a new NodeId")?;
-                            local_enr.set_seq(new_seq_no, &enr_key).map_err(|e| {
-                                format!("Could not update ENR sequence number: {:?}", e)
-                            })?;
-                            debug!(log, "ENR sequence number increased"; "seq" =>  new_seq_no);
-                        }
-                    }
-                    Err(e) => {
-                        warn!(log, "ENR from file could not be decoded"; "error" => format!("{:?}", e));
-                    }
-                }
-            }
-        }
-    }
-
-    save_enr_to_disk(&config.network_dir, &local_enr, log);
-
+    use_or_load_enr(&enr_key, &mut local_enr, config, log)?;
    Ok(local_enr)
 }

-/// Builds a lighthouse ENR given a `NetworkConfig`.
-pub fn build_enr<T: EthSpec>(
-    enr_key: &CombinedKey,
-    config: &NetworkConfig,
-    enr_fork_id: EnrForkId,
-) -> Result<Enr, String> {
+pub fn create_enr_builder_from_config<T: EnrKey>(config: &NetworkConfig) -> EnrBuilder<T> {
    let mut builder = EnrBuilder::new("v4");
    if let Some(enr_address) = config.enr_address {
        builder.ip(enr_address);
@@ -120,7 +131,17 @@ pub fn build_enr<T: EthSpec>(
    // we always give it our listening tcp port
    // TODO: Add uPnP support to map udp and tcp ports
    let tcp_port = config.enr_tcp_port.unwrap_or_else(|| config.libp2p_port);
-    builder.tcp(tcp_port);
+    builder.tcp(tcp_port).tcp(config.libp2p_port);
+    builder
+}
+
+/// Builds a lighthouse ENR given a `NetworkConfig`.
+pub fn build_enr<T: EthSpec>(
+    enr_key: &CombinedKey,
+    config: &NetworkConfig,
+    enr_fork_id: EnrForkId,
+) -> Result<Enr, String> {
+    let mut builder = create_enr_builder_from_config(config);

    // set the `eth2` field on our ENR
    builder.add_value(ETH2_ENR_KEY.into(), enr_fork_id.as_ssz_bytes());
@@ -131,7 +152,6 @@ pub fn build_enr<T: EthSpec>(
    builder.add_value(BITFIELD_ENR_KEY.into(), bitfield.as_ssz_bytes());

    builder
-        .tcp(config.libp2p_port)
        .build(enr_key)
        .map_err(|e| format!("Could not build Local ENR: {:?}", e))
 }
--- a/beacon_node/eth2_libp2p/src/discovery/mod.rs
+++ b/beacon_node/eth2_libp2p/src/discovery/mod.rs
@@ -3,7 +3,7 @@ pub(crate) mod enr;
 pub mod enr_ext;

 // Allow external use of the lighthouse ENR builder
-pub use enr::{build_enr, CombinedKey, Eth2Enr};
+pub use enr::{build_enr, create_enr_builder_from_config, use_or_load_enr, CombinedKey, Eth2Enr};
 pub use enr_ext::{CombinedKeyExt, EnrExt};
 pub use libp2p::core::identity::Keypair;

--- a/beacon_node/eth2_libp2p/src/lib.rs
+++ b/beacon_node/eth2_libp2p/src/lib.rs
@@ -26,4 +26,4 @@ pub use metrics::scrape_discovery_metrics;
 pub use peer_manager::{
    client::Client, score::PeerAction, PeerDB, PeerInfo, PeerSyncStatus, SyncInfo,
 };
-pub use service::{Libp2pEvent, Service, NETWORK_KEY_FILENAME};
+pub use service::{load_private_key, Libp2pEvent, Service, NETWORK_KEY_FILENAME};
--- a/beacon_node/eth2_libp2p/src/peer_manager/peer_info.rs
+++ b/beacon_node/eth2_libp2p/src/peer_manager/peer_info.rs
@@ -7,6 +7,7 @@ use serde::{
    ser::{SerializeStructVariant, Serializer},
    Serialize,
 };
+use std::net::IpAddr;
 use std::time::Instant;
 use types::{EthSpec, SubnetId};
 use PeerConnectionStatus::*;
@@ -104,6 +105,8 @@ pub enum PeerConnectionStatus {
    Banned {
        /// moment when the peer was banned.
        since: Instant,
+        /// ip addresses this peer had a the moment of the ban
+        ip_addresses: Vec<IpAddr>,
    },
    /// We are currently dialing this peer.
    Dialing {
@@ -129,7 +132,7 @@ impl Serialize for PeerConnectionStatus {
                s.serialize_field("since", &since.elapsed().as_secs())?;
                s.end()
            }
-            Banned { since } => {
+            Banned { since, .. } => {
                let mut s = serializer.serialize_struct_variant("", 2, "Banned", 1)?;
                s.serialize_field("since", &since.elapsed().as_secs())?;
                s.end()
@@ -218,15 +221,16 @@ impl PeerConnectionStatus {
    }

    /// Modifies the status to Banned
-    pub fn ban(&mut self) {
+    pub fn ban(&mut self, ip_addresses: Vec<IpAddr>) {
        *self = Banned {
            since: Instant::now(),
+            ip_addresses,
        };
    }

    /// The score system has unbanned the peer. Update the connection status
    pub fn unban(&mut self) {
-        if let PeerConnectionStatus::Banned { since } = self {
+        if let PeerConnectionStatus::Banned { since, .. } = self {
            *self = PeerConnectionStatus::Disconnected { since: *since }
        }
    }
--- a/beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs
+++ b/beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs
@@ -1,11 +1,13 @@
 use super::peer_info::{PeerConnectionStatus, PeerInfo};
 use super::peer_sync_status::PeerSyncStatus;
 use super::score::{Score, ScoreState};
+use crate::multiaddr::Protocol;
 use crate::rpc::methods::MetaData;
 use crate::PeerId;
 use rand::seq::SliceRandom;
 use slog::{crit, debug, trace, warn};
 use std::collections::HashMap;
+use std::net::IpAddr;
 use std::time::Instant;
 use types::{EthSpec, SubnetId};

@@ -13,6 +15,9 @@ use types::{EthSpec, SubnetId};
 const MAX_DC_PEERS: usize = 500;
 /// The maximum number of banned nodes to remember.
 const MAX_BANNED_PEERS: usize = 1000;
+/// If there are more than `BANNED_PEERS_PER_IP_THRESHOLD` many banned peers with the same IP we ban
+/// the IP.
+const BANNED_PEERS_PER_IP_THRESHOLD: usize = 5;

 /// Storage of known peers, their reputation and information
 pub struct PeerDB<TSpec: EthSpec> {
@@ -20,18 +25,72 @@ pub struct PeerDB<TSpec: EthSpec> {
    peers: HashMap<PeerId, PeerInfo<TSpec>>,
    /// The number of disconnected nodes in the database.
    disconnected_peers: usize,
-    /// The number of banned peers in the database.
-    banned_peers: usize,
+    /// Counts banned peers in total and per ip
+    banned_peers_count: BannedPeersCount,
    /// PeerDB's logger
    log: slog::Logger,
 }

+pub struct BannedPeersCount {
+    /// The number of banned peers in the database.
+    banned_peers: usize,
+    /// maps ips to number of banned peers with this ip
+    banned_peers_per_ip: HashMap<IpAddr, usize>,
+}
+
+impl BannedPeersCount {
+    /// Removes the peer from the counts if it is banned. Returns true if the peer was banned and
+    /// false otherwise.
+    pub fn remove_banned_peer(&mut self, connection_status: &PeerConnectionStatus) -> bool {
+        match connection_status {
+            PeerConnectionStatus::Banned { ip_addresses, .. } => {
+                self.banned_peers = self.banned_peers.saturating_sub(1);
+                for address in ip_addresses {
+                    if let Some(count) = self.banned_peers_per_ip.get_mut(address) {
+                        *count = count.saturating_sub(1);
+                    }
+                }
+                true
+            }
+            _ => false, //if not banned do nothing
+        }
+    }
+
+    pub fn add_banned_peer(&mut self, connection_status: &PeerConnectionStatus) {
+        if let PeerConnectionStatus::Banned { ip_addresses, .. } = connection_status {
+            self.banned_peers += 1;
+            for address in ip_addresses {
+                *self.banned_peers_per_ip.entry(*address).or_insert(0) += 1;
+            }
+        }
+    }
+
+    pub fn banned_peers(&self) -> usize {
+        self.banned_peers
+    }
+
+    /// An IP is considered banned if more than BANNED_PEERS_PER_IP_THRESHOLD banned peers
+    /// exist with this IP
+    pub fn ip_is_banned(&self, ip: &IpAddr) -> bool {
+        self.banned_peers_per_ip
+            .get(ip)
+            .map_or(false, |count| *count > BANNED_PEERS_PER_IP_THRESHOLD)
+    }
+
+    pub fn new() -> Self {
+        BannedPeersCount {
+            banned_peers: 0,
+            banned_peers_per_ip: HashMap::new(),
+        }
+    }
+}
+
 impl<TSpec: EthSpec> PeerDB<TSpec> {
    pub fn new(log: &slog::Logger) -> Self {
        Self {
            log: log.clone(),
            disconnected_peers: 0,
-            banned_peers: 0,
+            banned_peers_count: BannedPeersCount::new(),
            peers: HashMap::new(),
        }
    }
@@ -99,17 +158,35 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {

    /// Returns true if the Peer is banned.
    pub fn is_banned(&self, peer_id: &PeerId) -> bool {
-        match self.peers.get(peer_id).map(|info| info.score.state()) {
-            Some(ScoreState::Banned) => true,
-            _ => false,
+        if let Some(peer) = self.peers.get(peer_id) {
+            match peer.score.state() {
+                ScoreState::Banned => true,
+                _ => self.ip_is_banned(peer),
+            }
+        } else {
+            false
        }
    }

+    fn ip_is_banned(&self, peer: &PeerInfo<TSpec>) -> bool {
+        peer.listening_addresses.iter().any(|addr| {
+            addr.iter().any(|p| match p {
+                Protocol::Ip4(ip) => self.banned_peers_count.ip_is_banned(&ip.into()),
+                Protocol::Ip6(ip) => self.banned_peers_count.ip_is_banned(&ip.into()),
+                _ => false,
+            })
+        })
+    }
+
    /// Returns true if the Peer is either banned or in the disconnected state.
    pub fn is_banned_or_disconnected(&self, peer_id: &PeerId) -> bool {
-        match self.peers.get(peer_id).map(|info| info.score.state()) {
-            Some(ScoreState::Banned) | Some(ScoreState::Disconnected) => true,
-            _ => false,
+        if let Some(peer) = self.peers.get(peer_id) {
+            match peer.score.state() {
+                ScoreState::Banned | ScoreState::Disconnected => true,
+                _ => self.ip_is_banned(peer),
+            }
+        } else {
+            false
        }
    }

@@ -233,9 +310,10 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
        if info.connection_status.is_disconnected() {
            self.disconnected_peers = self.disconnected_peers.saturating_sub(1);
        }
-        if info.connection_status.is_banned() {
-            self.banned_peers = self.banned_peers.saturating_sub(1);
-        }
+
+        self.banned_peers_count
+            .remove_banned_peer(&info.connection_status);
+
        info.connection_status = PeerConnectionStatus::Dialing {
            since: Instant::now(),
        };
@@ -284,9 +362,8 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
        if info.connection_status.is_disconnected() {
            self.disconnected_peers = self.disconnected_peers.saturating_sub(1);
        }
-        if info.connection_status.is_banned() {
-            self.banned_peers = self.banned_peers.saturating_sub(1);
-        }
+        self.banned_peers_count
+            .remove_banned_peer(&info.connection_status);
        info.connection_status.connect_ingoing();
    }

@@ -297,9 +374,8 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
        if info.connection_status.is_disconnected() {
            self.disconnected_peers = self.disconnected_peers.saturating_sub(1);
        }
-        if info.connection_status.is_banned() {
-            self.banned_peers = self.banned_peers.saturating_sub(1);
-        }
+        self.banned_peers_count
+            .remove_banned_peer(&info.connection_status);
        info.connection_status.connect_outgoing();
    }

@@ -329,8 +405,23 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
            self.disconnected_peers = self.disconnected_peers.saturating_sub(1);
        }
        if !info.connection_status.is_banned() {
-            info.connection_status.ban();
-            self.banned_peers += 1;
+            info.connection_status
+                .ban(
+                    info.listening_addresses
+                        .iter()
+                        .fold(Vec::new(), |mut v, a| {
+                            for p in a {
+                                match p {
+                                    Protocol::Ip4(ip) => v.push(ip.into()),
+                                    Protocol::Ip6(ip) => v.push(ip.into()),
+                                    _ => (),
+                                }
+                            }
+                            v
+                        }),
+                );
+            self.banned_peers_count
+                .add_banned_peer(&info.connection_status);
        }
        self.shrink_to_fit();
    }
@@ -345,8 +436,9 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
        });

        if info.connection_status.is_banned() {
+            self.banned_peers_count
+                .remove_banned_peer(&info.connection_status);
            info.connection_status.unban();
-            self.banned_peers = self.banned_peers.saturating_sub(1);
        }
        self.shrink_to_fit();
    }
@@ -355,9 +447,9 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
    /// Drops the peers with the lowest reputation so that the number of
    /// disconnected peers is less than MAX_DC_PEERS
    pub fn shrink_to_fit(&mut self) {
-        // Remove excess baned peers
-        while self.banned_peers > MAX_BANNED_PEERS {
-            if let Some(to_drop) = self
+        // Remove excess banned peers
+        while self.banned_peers_count.banned_peers() > MAX_BANNED_PEERS {
+            if let Some(to_drop) = if let Some((id, info)) = self
                .peers
                .iter()
                .filter(|(_, info)| info.connection_status.is_banned())
@@ -366,15 +458,23 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
                        .score
                        .partial_cmp(&info_b.score)
                        .unwrap_or(std::cmp::Ordering::Equal)
-                })
-                .map(|(id, _)| id.clone())
-            {
+                }) {
+                self.banned_peers_count
+                    .remove_banned_peer(&info.connection_status);
+                Some(id.clone())
+            } else {
+                // If there is no minimum, this is a coding error.
+                crit!(
+                    self.log,
+                    "banned_peers > MAX_BANNED_PEERS despite no banned peers in db!"
+                );
+                // reset banned_peers this will also exit the loop
+                self.banned_peers_count = BannedPeersCount::new();
+                None
+            } {
                debug!(self.log, "Removing old banned peer"; "peer_id" => to_drop.to_string());
                self.peers.remove(&to_drop);
            }
-            // If there is no minimum, this is a coding error. For safety we decrease
-            // the count to avoid a potential infinite loop.
-            self.banned_peers = self.banned_peers.saturating_sub(1);
        }

        // Remove excess disconnected peers
@@ -422,8 +522,11 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use libp2p::core::Multiaddr;
    use slog::{o, Drain};
+    use std::net::{Ipv4Addr, Ipv6Addr};
    use types::MinimalEthSpec;
+
    type M = MinimalEthSpec;

    pub fn build_log(level: slog::Level, enabled: bool) -> slog::Logger {
@@ -503,13 +606,13 @@ mod tests {
            let p = PeerId::random();
            pdb.connect_ingoing(&p);
        }
-        assert_eq!(pdb.banned_peers, 0);
+        assert_eq!(pdb.banned_peers_count.banned_peers(), 0);

        for p in pdb.connected_peer_ids().cloned().collect::<Vec<_>>() {
            pdb.ban(&p);
        }

-        assert_eq!(pdb.banned_peers, MAX_BANNED_PEERS);
+        assert_eq!(pdb.banned_peers_count.banned_peers(), MAX_BANNED_PEERS);
    }

    #[test]
@@ -608,24 +711,39 @@ mod tests {
        pdb.connect_ingoing(&random_peer2);
        pdb.connect_ingoing(&random_peer3);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );

        pdb.connect_ingoing(&random_peer);
        pdb.disconnect(&random_peer1);
        pdb.ban(&random_peer2);
        pdb.connect_ingoing(&random_peer3);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );
        pdb.ban(&random_peer1);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );

        pdb.connect_outgoing(&random_peer2);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );
        pdb.ban(&random_peer3);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );

        pdb.ban(&random_peer3);
        pdb.connect_ingoing(&random_peer1);
@@ -633,15 +751,191 @@ mod tests {
        pdb.ban(&random_peer3);
        pdb.connect_ingoing(&random_peer);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );
        pdb.disconnect(&random_peer);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );

        pdb.disconnect(&random_peer);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
-        assert_eq!(pdb.banned_peers, pdb.banned_peers().count());
+        assert_eq!(
+            pdb.banned_peers_count.banned_peers(),
+            pdb.banned_peers().count()
+        );
        pdb.ban(&random_peer);
        assert_eq!(pdb.disconnected_peers, pdb.disconnected_peers().count());
    }
+
+    fn connect_peer_with_ips(pdb: &mut PeerDB<M>, ips: Vec<Vec<IpAddr>>) -> PeerId {
+        let p = PeerId::random();
+        pdb.connect_ingoing(&p);
+        pdb.peers.get_mut(&p).unwrap().listening_addresses = ips
+            .into_iter()
+            .map(|ip_addresses| {
+                let mut addr = Multiaddr::empty();
+                for ip_address in ip_addresses {
+                    addr.push(Protocol::from(ip_address));
+                }
+                addr
+            })
+            .collect();
+        p
+    }
+
+    #[test]
+    fn test_ban_address() {
+        let mut pdb = get_db();
+
+        let ip1: IpAddr = Ipv4Addr::new(1, 2, 3, 4).into();
+        let ip2: IpAddr = Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8).into();
+        let ip3: IpAddr = Ipv4Addr::new(1, 2, 3, 5).into();
+        let ip4: IpAddr = Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 9).into();
+        let ip5: IpAddr = Ipv4Addr::new(2, 2, 3, 4).into();
+
+        let mut peers = Vec::new();
+        for i in 0..BANNED_PEERS_PER_IP_THRESHOLD + 2 {
+            peers.push(connect_peer_with_ips(
+                &mut pdb,
+                if i == 0 {
+                    vec![vec![ip1], vec![ip2]]
+                } else {
+                    vec![vec![ip1, ip2], vec![ip3, ip4]]
+                },
+            ));
+        }
+
+        let p1 = connect_peer_with_ips(&mut pdb, vec![vec![ip1]]);
+        let p2 = connect_peer_with_ips(&mut pdb, vec![vec![ip2, ip5]]);
+        let p3 = connect_peer_with_ips(&mut pdb, vec![vec![ip3], vec![ip5]]);
+        let p4 = connect_peer_with_ips(&mut pdb, vec![vec![ip5, ip4]]);
+        let p5 = connect_peer_with_ips(&mut pdb, vec![vec![ip5]]);
+
+        for p in &peers[..BANNED_PEERS_PER_IP_THRESHOLD + 1] {
+            pdb.ban(p);
+        }
+
+        //check that ip1 and ip2 are banned but ip3-5 not
+        assert!(pdb.is_banned(&p1));
+        assert!(pdb.is_banned(&p2));
+        assert!(!pdb.is_banned(&p3));
+        assert!(!pdb.is_banned(&p4));
+        assert!(!pdb.is_banned(&p5));
+
+        //ban also the last peer in peers
+        pdb.ban(&peers[BANNED_PEERS_PER_IP_THRESHOLD + 1]);
+
+        //check that ip1-ip4 are banned but ip5 not
+        assert!(pdb.is_banned(&p1));
+        assert!(pdb.is_banned(&p2));
+        assert!(pdb.is_banned(&p3));
+        assert!(pdb.is_banned(&p4));
+        assert!(!pdb.is_banned(&p5));
+
+        //peers[0] gets unbanned
+        pdb.unban(&peers[0]);
+
+        //nothing changed
+        assert!(pdb.is_banned(&p1));
+        assert!(pdb.is_banned(&p2));
+        assert!(pdb.is_banned(&p3));
+        assert!(pdb.is_banned(&p4));
+        assert!(!pdb.is_banned(&p5));
+
+        //peers[1] gets unbanned
+        pdb.unban(&peers[1]);
+
+        //all ips are unbanned
+        assert!(!pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+        assert!(!pdb.is_banned(&p3));
+        assert!(!pdb.is_banned(&p4));
+        assert!(!pdb.is_banned(&p5));
+    }
+
+    #[test]
+    fn test_banned_ip_consistent_after_changing_ips() {
+        let mut pdb = get_db();
+
+        let ip1: IpAddr = Ipv4Addr::new(1, 2, 3, 4).into();
+        let ip2: IpAddr = Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8).into();
+
+        let mut peers = Vec::new();
+        for _ in 0..BANNED_PEERS_PER_IP_THRESHOLD + 1 {
+            peers.push(connect_peer_with_ips(&mut pdb, vec![vec![ip1]]));
+        }
+
+        let p1 = connect_peer_with_ips(&mut pdb, vec![vec![ip1]]);
+        let p2 = connect_peer_with_ips(&mut pdb, vec![vec![ip2]]);
+
+        //ban all peers
+        for p in &peers {
+            pdb.ban(p);
+        }
+
+        //check ip is banned
+        assert!(pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+
+        //change addresses of banned peers
+        for p in &peers {
+            pdb.peers.get_mut(p).unwrap().listening_addresses =
+                vec![Multiaddr::empty().with(Protocol::from(ip2))];
+        }
+
+        //check still the same ip is banned
+        assert!(pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+
+        //unban a peer
+        pdb.unban(&peers[0]);
+
+        //check not banned anymore
+        assert!(!pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+
+        //check still not banned after new ban
+        pdb.ban(&peers[0]);
+        assert!(!pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+
+        //unban and reban all peers
+        for p in &peers {
+            pdb.unban(p);
+            pdb.ban(p);
+        }
+
+        //ip2 is now banned
+        assert!(!pdb.is_banned(&p1));
+        assert!(pdb.is_banned(&p2));
+
+        //change ips back again
+        for p in &peers {
+            pdb.peers.get_mut(p).unwrap().listening_addresses =
+                vec![Multiaddr::empty().with(Protocol::from(ip1))];
+        }
+
+        //reban every peer except one
+        for p in &peers[1..] {
+            pdb.unban(p);
+            pdb.ban(p);
+        }
+
+        //nothing is banned
+        assert!(!pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+
+        //reban last peer
+        pdb.unban(&peers[0]);
+        pdb.ban(&peers[0]);
+
+        //ip1 is banned
+        assert!(pdb.is_banned(&p1));
+        assert!(!pdb.is_banned(&p2));
+    }
 }
--- a/beacon_node/eth2_libp2p/src/service.rs
+++ b/beacon_node/eth2_libp2p/src/service.rs
@@ -357,7 +357,7 @@ fn keypair_from_bytes(mut bytes: Vec<u8>) -> error::Result<Keypair> {
 /// generated and is then saved to disk.
 ///
 /// Currently only secp256k1 keys are allowed, as these are the only keys supported by discv5.
-fn load_private_key(config: &NetworkConfig, log: &slog::Logger) -> Keypair {
+pub fn load_private_key(config: &NetworkConfig, log: &slog::Logger) -> Keypair {
    // check for key from disk
    let network_key_f = config.network_dir.join(NETWORK_KEY_FILENAME);
    if let Ok(mut network_key_file) = File::open(network_key_f.clone()) {
--- a/beacon_node/network/src/service/tests.rs
+++ b/beacon_node/network/src/service/tests.rs
@@ -23,7 +23,7 @@ mod tests {
        let log = get_logger();

        let beacon_chain = Arc::new(
-            BeaconChainHarness::new(
+            BeaconChainHarness::new_with_store_config(
                MinimalEthSpec,
                generate_deterministic_keypairs(8),
                StoreConfig::default(),
--- a/beacon_node/rest_api/Cargo.toml
+++ b/beacon_node/rest_api/Cargo.toml
@@ -34,7 +34,6 @@ hex = "0.4.2"
 parking_lot = "0.11.0"
 futures = "0.3.5"
 operation_pool = { path = "../operation_pool" }
-rayon = "1.3.0"
 environment = { path = "../../lighthouse/environment" }
 uhttp_sse = "0.5.1"
 bus = "2.2.3"
--- a/beacon_node/rest_api/src/advanced.rs
+++ b/beacon_node/rest_api/src/advanced.rs
@@ -1,34 +0,0 @@
-use crate::response_builder::ResponseBuilder;
-use crate::ApiResult;
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use hyper::{Body, Request};
-use operation_pool::PersistedOperationPool;
-use std::sync::Arc;
-
-/// Returns the `proto_array` fork choice struct, encoded as JSON.
-///
-/// Useful for debugging or advanced inspection of the chain.
-pub fn get_fork_choice<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(
-        &*beacon_chain
-            .fork_choice
-            .read()
-            .proto_array()
-            .core_proto_array(),
-    )
-}
-
-/// Returns the `PersistedOperationPool` struct.
-///
-/// Useful for debugging or advanced inspection of the stored operations.
-pub fn get_operation_pool<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&PersistedOperationPool::from_operation_pool(
-        &beacon_chain.op_pool,
-    ))
-}
--- a/beacon_node/rest_api/src/beacon.rs
+++ b/beacon_node/rest_api/src/beacon.rs
@@ -1,14 +1,13 @@
 use crate::helpers::*;
-use crate::response_builder::ResponseBuilder;
 use crate::validator::get_state_for_epoch;
-use crate::{ApiError, ApiResult, UrlQuery};
+use crate::Context;
+use crate::{ApiError, UrlQuery};
 use beacon_chain::{
    observed_operations::ObservationOutcome, BeaconChain, BeaconChainTypes, StateSkipConfig,
 };
-use bus::BusReader;
 use futures::executor::block_on;
 use hyper::body::Bytes;
-use hyper::{Body, Request, Response};
+use hyper::{Body, Request};
 use rest_types::{
    BlockResponse, CanonicalHeadResponse, Committee, HeadBeaconBlock, StateResponse,
    ValidatorRequest, ValidatorResponse,
@@ -16,20 +15,20 @@ use rest_types::{
 use std::io::Write;
 use std::sync::Arc;

-use slog::{error, Logger};
+use slog::error;
 use types::{
    AttesterSlashing, BeaconState, EthSpec, Hash256, ProposerSlashing, PublicKeyBytes,
    RelativeEpoch, SignedBeaconBlockHash, Slot,
 };

-/// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
+/// Returns a summary of the head of the beacon chain.
 pub fn get_head<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    ctx: Arc<Context<T>>,
+) -> Result<CanonicalHeadResponse, ApiError> {
+    let beacon_chain = &ctx.beacon_chain;
    let chain_head = beacon_chain.head()?;

-    let head = CanonicalHeadResponse {
+    Ok(CanonicalHeadResponse {
        slot: chain_head.beacon_state.slot,
        block_root: chain_head.beacon_block_root,
        state_root: chain_head.beacon_state_root,
@@ -51,33 +50,27 @@ pub fn get_head<T: BeaconChainTypes>(
            .epoch
            .start_slot(T::EthSpec::slots_per_epoch()),
        previous_justified_block_root: chain_head.beacon_state.previous_justified_checkpoint.root,
-    };
-
-    ResponseBuilder::new(&req)?.body(&head)
+    })
 }

-/// HTTP handler to return a list of head BeaconBlocks.
-pub fn get_heads<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let heads = beacon_chain
+/// Return the list of heads of the beacon chain.
+pub fn get_heads<T: BeaconChainTypes>(ctx: Arc<Context<T>>) -> Vec<HeadBeaconBlock> {
+    ctx.beacon_chain
        .heads()
        .into_iter()
        .map(|(beacon_block_root, beacon_block_slot)| HeadBeaconBlock {
            beacon_block_root,
            beacon_block_slot,
        })
-        .collect::<Vec<_>>();
-
-    ResponseBuilder::new(&req)?.body(&heads)
+        .collect()
 }

 /// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
 pub fn get_block<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<BlockResponse<T::EthSpec>, ApiError> {
+    let beacon_chain = &ctx.beacon_chain;
    let query_params = ["root", "slot"];
    let (key, value) = UrlQuery::from_request(&req)?.first_of(&query_params)?;

@@ -85,7 +78,7 @@ pub fn get_block<T: BeaconChainTypes>(
        ("slot", value) => {
            let target = parse_slot(&value)?;

-            block_root_at_slot(&beacon_chain, target)?.ok_or_else(|| {
+            block_root_at_slot(beacon_chain, target)?.ok_or_else(|| {
                ApiError::NotFound(format!(
                    "Unable to find SignedBeaconBlock for slot {:?}",
                    target
@@ -103,30 +96,26 @@ pub fn get_block<T: BeaconChainTypes>(
        ))
    })?;

-    let response = BlockResponse {
+    Ok(BlockResponse {
        root: block_root,
        beacon_block: block,
-    };
-
-    ResponseBuilder::new(&req)?.body(&response)
+    })
 }

 /// HTTP handler to return a `SignedBeaconBlock` root at a given `slot`.
 pub fn get_block_root<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Hash256, ApiError> {
    let slot_string = UrlQuery::from_request(&req)?.only_one("slot")?;
    let target = parse_slot(&slot_string)?;

-    let root = block_root_at_slot(&beacon_chain, target)?.ok_or_else(|| {
+    block_root_at_slot(&ctx.beacon_chain, target)?.ok_or_else(|| {
        ApiError::NotFound(format!(
            "Unable to find SignedBeaconBlock for slot {:?}",
            target
        ))
-    })?;
-
-    ResponseBuilder::new(&req)?.body(&root)
+    })
 }

 fn make_sse_response_chunk(new_head_hash: SignedBeaconBlockHash) -> std::io::Result<Bytes> {
@@ -140,45 +129,27 @@ fn make_sse_response_chunk(new_head_hash: SignedBeaconBlockHash) -> std::io::Res
    Ok(bytes)
 }

-pub fn stream_forks<T: BeaconChainTypes>(
-    log: Logger,
-    mut events: BusReader<SignedBeaconBlockHash>,
-) -> ApiResult {
+pub fn stream_forks<T: BeaconChainTypes>(ctx: Arc<Context<T>>) -> Result<Body, ApiError> {
+    let mut events = ctx.events.lock().add_rx();
    let (mut sender, body) = Body::channel();
    std::thread::spawn(move || {
        while let Ok(new_head_hash) = events.recv() {
            let chunk = match make_sse_response_chunk(new_head_hash) {
                Ok(chunk) => chunk,
                Err(e) => {
-                    error!(log, "Failed to make SSE chunk"; "error" => e.to_string());
+                    error!(ctx.log, "Failed to make SSE chunk"; "error" => e.to_string());
                    sender.abort();
                    break;
                }
            };
            match block_on(sender.send_data(chunk)) {
                Err(e) if e.is_closed() => break,
-                Err(e) => error!(log, "Couldn't stream piece {:?}", e),
+                Err(e) => error!(ctx.log, "Couldn't stream piece {:?}", e),
                Ok(_) => (),
            }
        }
    });
-    let response = Response::builder()
-        .status(200)
-        .header("Content-Type", "text/event-stream")
-        .header("Connection", "Keep-Alive")
-        .header("Cache-Control", "no-cache")
-        .header("Access-Control-Allow-Origin", "*")
-        .body(body)
-        .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))?;
-    Ok(response)
-}
-
-/// HTTP handler to return the `Fork` of the current head.
-pub fn get_fork<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&beacon_chain.head()?.beacon_state.fork)
+    Ok(body)
 }

 /// HTTP handler to which accepts a query string of a list of validator pubkeys and maps it to a
@@ -187,9 +158,9 @@ pub fn get_fork<T: BeaconChainTypes>(
 /// This method is limited to as many `pubkeys` that can fit in a URL. See `post_validators` for
 /// doing bulk requests.
 pub fn get_validators<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorResponse>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let validator_pubkeys = query
@@ -204,17 +175,14 @@ pub fn get_validators<T: BeaconChainTypes>(
        None
    };

-    let validators =
-        validator_responses_by_pubkey(beacon_chain, state_root_opt, validator_pubkeys)?;
-
-    ResponseBuilder::new(&req)?.body(&validators)
+    validator_responses_by_pubkey(&ctx.beacon_chain, state_root_opt, validator_pubkeys)
 }

 /// HTTP handler to return all validators, each as a `ValidatorResponse`.
 pub fn get_all_validators<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorResponse>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let state_root_opt = if let Some((_key, value)) = query.first_of_opt(&["state_root"]) {
@@ -223,23 +191,21 @@ pub fn get_all_validators<T: BeaconChainTypes>(
        None
    };

-    let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
+    let mut state = get_state_from_root_opt(&ctx.beacon_chain, state_root_opt)?;
    state.update_pubkey_cache()?;

-    let validators = state
+    state
        .validators
        .iter()
        .map(|validator| validator_response_by_pubkey(&state, validator.pubkey.clone()))
-        .collect::<Result<Vec<_>, _>>()?;
-
-    ResponseBuilder::new(&req)?.body(&validators)
+        .collect::<Result<Vec<_>, _>>()
 }

 /// HTTP handler to return all active validators, each as a `ValidatorResponse`.
 pub fn get_active_validators<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorResponse>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let state_root_opt = if let Some((_key, value)) = query.first_of_opt(&["state_root"]) {
@@ -248,17 +214,15 @@ pub fn get_active_validators<T: BeaconChainTypes>(
        None
    };

-    let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
+    let mut state = get_state_from_root_opt(&ctx.beacon_chain, state_root_opt)?;
    state.update_pubkey_cache()?;

-    let validators = state
+    state
        .validators
        .iter()
        .filter(|validator| validator.is_active_at(state.current_epoch()))
        .map(|validator| validator_response_by_pubkey(&state, validator.pubkey.clone()))
-        .collect::<Result<Vec<_>, _>>()?;
-
-    ResponseBuilder::new(&req)?.body(&validators)
+        .collect::<Result<Vec<_>, _>>()
 }

 /// HTTP handler to which accepts a `ValidatorRequest` and returns a `ValidatorResponse` for
@@ -266,17 +230,11 @@ pub fn get_active_validators<T: BeaconChainTypes>(
 ///
 /// This method allows for a basically unbounded list of `pubkeys`, where as the `get_validators`
 /// request is limited by the max number of pubkeys you can fit in a URL.
-pub async fn post_validators<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let response_builder = ResponseBuilder::new(&req);
-
-    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
-    serde_json::from_slice::<ValidatorRequest>(&chunks)
+pub fn post_validators<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorResponse>, ApiError> {
+    serde_json::from_slice::<ValidatorRequest>(&req.into_body())
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to parse JSON into ValidatorRequest: {:?}",
@@ -285,12 +243,11 @@ pub async fn post_validators<T: BeaconChainTypes>(
        })
        .and_then(|bulk_request| {
            validator_responses_by_pubkey(
-                beacon_chain,
+                &ctx.beacon_chain,
                bulk_request.state_root,
                bulk_request.pubkeys,
            )
        })
-        .and_then(|validators| response_builder?.body(&validators))
 }

 /// Returns either the state given by `state_root_opt`, or the canonical head state if it is
@@ -317,11 +274,11 @@ fn get_state_from_root_opt<T: BeaconChainTypes>(
 /// Maps a vec of `validator_pubkey` to a vec of `ValidatorResponse`, using the state at the given
 /// `state_root`. If `state_root.is_none()`, uses the canonial head state.
 fn validator_responses_by_pubkey<T: BeaconChainTypes>(
-    beacon_chain: Arc<BeaconChain<T>>,
+    beacon_chain: &BeaconChain<T>,
    state_root_opt: Option<Hash256>,
    validator_pubkeys: Vec<PublicKeyBytes>,
 ) -> Result<Vec<ValidatorResponse>, ApiError> {
-    let mut state = get_state_from_root_opt(&beacon_chain, state_root_opt)?;
+    let mut state = get_state_from_root_opt(beacon_chain, state_root_opt)?;
    state.update_pubkey_cache()?;

    validator_pubkeys
@@ -372,24 +329,25 @@ fn validator_response_by_pubkey<E: EthSpec>(

 /// HTTP handler
 pub fn get_committees<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<Committee>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let epoch = query.epoch()?;

-    let mut state = get_state_for_epoch(&beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;
+    let mut state =
+        get_state_for_epoch(&ctx.beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;

    let relative_epoch = RelativeEpoch::from_epoch(state.current_epoch(), epoch).map_err(|e| {
        ApiError::ServerError(format!("Failed to get state suitable for epoch: {:?}", e))
    })?;

    state
-        .build_committee_cache(relative_epoch, &beacon_chain.spec)
+        .build_committee_cache(relative_epoch, &ctx.beacon_chain.spec)
        .map_err(|e| ApiError::ServerError(format!("Unable to build committee cache: {:?}", e)))?;

-    let committees = state
+    Ok(state
        .get_beacon_committees_at_epoch(relative_epoch)
        .map_err(|e| ApiError::ServerError(format!("Unable to get all committees: {:?}", e)))?
        .into_iter()
@@ -398,9 +356,7 @@ pub fn get_committees<T: BeaconChainTypes>(
            index: c.index,
            committee: c.committee.to_vec(),
        })
-        .collect::<Vec<_>>();
-
-    ResponseBuilder::new(&req)?.body(&committees)
+        .collect::<Vec<_>>())
 }

 /// HTTP handler to return a `BeaconState` at a given `root` or `slot`.
@@ -408,10 +364,10 @@ pub fn get_committees<T: BeaconChainTypes>(
 /// Will not return a state if the request slot is in the future. Will return states higher than
 /// the current head by skipping slots.
 pub fn get_state<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let head_state = beacon_chain.head()?.beacon_state;
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<StateResponse<T::EthSpec>, ApiError> {
+    let head_state = ctx.beacon_chain.head()?.beacon_state;

    let (key, value) = match UrlQuery::from_request(&req) {
        Ok(query) => {
@@ -429,11 +385,12 @@ pub fn get_state<T: BeaconChainTypes>(
    };

    let (root, state): (Hash256, BeaconState<T::EthSpec>) = match (key.as_ref(), value) {
-        ("slot", value) => state_at_slot(&beacon_chain, parse_slot(&value)?)?,
+        ("slot", value) => state_at_slot(&ctx.beacon_chain, parse_slot(&value)?)?,
        ("root", value) => {
            let root = &parse_root(&value)?;

-            let state = beacon_chain
+            let state = ctx
+                .beacon_chain
                .store
                .get_state(root, None)?
                .ok_or_else(|| ApiError::NotFound(format!("No state for root: {:?}", root)))?;
@@ -443,12 +400,10 @@ pub fn get_state<T: BeaconChainTypes>(
        _ => return Err(ApiError::ServerError("Unexpected query parameter".into())),
    };

-    let response = StateResponse {
+    Ok(StateResponse {
        root,
        beacon_state: state,
-    };
-
-    ResponseBuilder::new(&req)?.body(&response)
+    })
 }

 /// HTTP handler to return a `BeaconState` root at a given `slot`.
@@ -456,15 +411,13 @@ pub fn get_state<T: BeaconChainTypes>(
 /// Will not return a state if the request slot is in the future. Will return states higher than
 /// the current head by skipping slots.
 pub fn get_state_root<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Hash256, ApiError> {
    let slot_string = UrlQuery::from_request(&req)?.only_one("slot")?;
    let slot = parse_slot(&slot_string)?;

-    let root = state_root_at_slot(&beacon_chain, slot, StateSkipConfig::WithStateRoots)?;
-
-    ResponseBuilder::new(&req)?.body(&root)
+    state_root_at_slot(&ctx.beacon_chain, slot, StateSkipConfig::WithStateRoots)
 }

 /// HTTP handler to return a `BeaconState` at the genesis block.
@@ -472,50 +425,28 @@ pub fn get_state_root<T: BeaconChainTypes>(
 /// This is an undocumented convenience method used during testing. For production, simply do a
 /// state request at slot 0.
 pub fn get_genesis_state<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let (_root, state) = state_at_slot(&beacon_chain, Slot::new(0))?;
-
-    ResponseBuilder::new(&req)?.body(&state)
+    ctx: Arc<Context<T>>,
+) -> Result<BeaconState<T::EthSpec>, ApiError> {
+    state_at_slot(&ctx.beacon_chain, Slot::new(0)).map(|(_root, state)| state)
 }

-/// Read the genesis time from the current beacon chain state.
-pub fn get_genesis_time<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_time)
-}
-
-/// Read the `genesis_validators_root` from the current beacon chain state.
-pub fn get_genesis_validators_root<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&beacon_chain.head_info()?.genesis_validators_root)
-}
-
-pub async fn proposer_slashing<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn proposer_slashing<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<bool, ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;

-    serde_json::from_slice::<ProposerSlashing>(&chunks)
+    serde_json::from_slice::<ProposerSlashing>(&body)
        .map_err(|e| format!("Unable to parse JSON into ProposerSlashing: {:?}", e))
        .and_then(move |proposer_slashing| {
-            if beacon_chain.eth1_chain.is_some() {
-                let obs_outcome = beacon_chain
+            if ctx.beacon_chain.eth1_chain.is_some() {
+                let obs_outcome = ctx
+                    .beacon_chain
                    .verify_proposer_slashing_for_gossip(proposer_slashing)
                    .map_err(|e| format!("Error while verifying proposer slashing: {:?}", e))?;
                if let ObservationOutcome::New(verified_proposer_slashing) = obs_outcome {
-                    beacon_chain.import_proposer_slashing(verified_proposer_slashing);
+                    ctx.beacon_chain
+                        .import_proposer_slashing(verified_proposer_slashing);
                    Ok(())
                } else {
                    Err("Proposer slashing for that validator index already known".into())
@@ -524,22 +455,17 @@ pub async fn proposer_slashing<T: BeaconChainTypes>(
                Err("Cannot insert proposer slashing on node without Eth1 connection.".to_string())
            }
        })
-        .map_err(ApiError::BadRequest)
-        .and_then(|_| response_builder?.body(&true))
+        .map_err(ApiError::BadRequest)?;
+
+    Ok(true)
 }

-pub async fn attester_slashing<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn attester_slashing<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<bool, ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
-
-    serde_json::from_slice::<AttesterSlashing<T::EthSpec>>(&chunks)
+    serde_json::from_slice::<AttesterSlashing<T::EthSpec>>(&body)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to parse JSON into AttesterSlashing: {:?}",
@@ -547,13 +473,13 @@ pub async fn attester_slashing<T: BeaconChainTypes>(
            ))
        })
        .and_then(move |attester_slashing| {
-            if beacon_chain.eth1_chain.is_some() {
-                beacon_chain
+            if ctx.beacon_chain.eth1_chain.is_some() {
+                ctx.beacon_chain
                    .verify_attester_slashing_for_gossip(attester_slashing)
                    .map_err(|e| format!("Error while verifying attester slashing: {:?}", e))
                    .and_then(|outcome| {
                        if let ObservationOutcome::New(verified_attester_slashing) = outcome {
-                            beacon_chain
+                            ctx.beacon_chain
                                .import_attester_slashing(verified_attester_slashing)
                                .map_err(|e| {
                                    format!("Error while importing attester slashing: {:?}", e)
@@ -568,6 +494,7 @@ pub async fn attester_slashing<T: BeaconChainTypes>(
                    "Cannot insert attester slashing on node without Eth1 connection.".to_string(),
                ))
            }
-        })
-        .and_then(|_| response_builder?.body(&true))
+        })?;
+
+    Ok(true)
 }
--- a/beacon_node/rest_api/src/consensus.rs
+++ b/beacon_node/rest_api/src/consensus.rs
@@ -1,8 +1,7 @@
 use crate::helpers::*;
-use crate::response_builder::ResponseBuilder;
-use crate::{ApiError, ApiResult, UrlQuery};
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use hyper::{Body, Request};
+use crate::{ApiError, Context, UrlQuery};
+use beacon_chain::BeaconChainTypes;
+use hyper::Request;
 use rest_types::{IndividualVotesRequest, IndividualVotesResponse};
 use serde::{Deserialize, Serialize};
 use ssz_derive::{Decode, Encode};
@@ -50,38 +49,31 @@ impl Into<VoteCount> for TotalBalances {

 /// HTTP handler return a `VoteCount` for some given `Epoch`.
 pub fn get_vote_count<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<VoteCount, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let epoch = query.epoch()?;
    // This is the last slot of the given epoch (one prior to the first slot of the next epoch).
    let target_slot = (epoch + 1).start_slot(T::EthSpec::slots_per_epoch()) - 1;

-    let (_root, state) = state_at_slot(&beacon_chain, target_slot)?;
-    let spec = &beacon_chain.spec;
+    let (_root, state) = state_at_slot(&ctx.beacon_chain, target_slot)?;
+    let spec = &ctx.beacon_chain.spec;

    let mut validator_statuses = ValidatorStatuses::new(&state, spec)?;
    validator_statuses.process_attestations(&state, spec)?;

-    let report: VoteCount = validator_statuses.total_balances.into();
-
-    ResponseBuilder::new(&req)?.body(&report)
+    Ok(validator_statuses.total_balances.into())
 }

-pub async fn post_individual_votes<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn post_individual_votes<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<IndividualVotesResponse>, ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;

-    serde_json::from_slice::<IndividualVotesRequest>(&chunks)
+    serde_json::from_slice::<IndividualVotesRequest>(&body)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to parse JSON into ValidatorDutiesRequest: {:?}",
@@ -94,8 +86,8 @@ pub async fn post_individual_votes<T: BeaconChainTypes>(
            // This is the last slot of the given epoch (one prior to the first slot of the next epoch).
            let target_slot = (epoch + 1).start_slot(T::EthSpec::slots_per_epoch()) - 1;

-            let (_root, mut state) = state_at_slot(&beacon_chain, target_slot)?;
-            let spec = &beacon_chain.spec;
+            let (_root, mut state) = state_at_slot(&ctx.beacon_chain, target_slot)?;
+            let spec = &ctx.beacon_chain.spec;

            let mut validator_statuses = ValidatorStatuses::new(&state, spec)?;
            validator_statuses.process_attestations(&state, spec)?;
@@ -135,5 +127,4 @@ pub async fn post_individual_votes<T: BeaconChainTypes>(
                })
                .collect::<Result<Vec<_>, _>>()
        })
-        .and_then(|votes| response_builder?.body_no_ssz(&votes))
 }
--- a/beacon_node/rest_api/src/helpers.rs
+++ b/beacon_node/rest_api/src/helpers.rs
@@ -1,9 +1,7 @@
-use crate::{ApiError, ApiResult, NetworkChannel};
+use crate::{ApiError, NetworkChannel};
 use beacon_chain::{BeaconChain, BeaconChainTypes, StateSkipConfig};
 use bls::PublicKeyBytes;
 use eth2_libp2p::PubsubMessage;
-use http::header;
-use hyper::{Body, Request};
 use itertools::process_results;
 use network::NetworkMessage;
 use ssz::Decode;
@@ -41,21 +39,6 @@ pub fn parse_committee_index(string: &str) -> Result<CommitteeIndex, ApiError> {
        .map_err(|e| ApiError::BadRequest(format!("Unable to parse committee index: {:?}", e)))
 }

-/// Checks the provided request to ensure that the `content-type` header.
-///
-/// The content-type header should either be omitted, in which case JSON is assumed, or it should
-/// explicitly specify `application/json`. If anything else is provided, an error is returned.
-pub fn check_content_type_for_json(req: &Request<Body>) -> Result<(), ApiError> {
-    match req.headers().get(header::CONTENT_TYPE) {
-        Some(h) if h == "application/json" => Ok(()),
-        Some(h) => Err(ApiError::BadRequest(format!(
-            "The provided content-type {:?} is not available, this endpoint only supports json.",
-            h
-        ))),
-        _ => Ok(()),
-    }
-}
-
 /// Parse an SSZ object from some hex-encoded bytes.
 ///
 /// E.g., A signature is `"0x0000000000000000000000000000000000000000000000000000000000000000"`
@@ -228,14 +211,8 @@ pub fn state_root_at_slot<T: BeaconChainTypes>(
    }
 }

-pub fn implementation_pending_response(_req: Request<Body>) -> ApiResult {
-    Err(ApiError::NotImplemented(
-        "API endpoint has not yet been implemented, but is planned to be soon.".to_owned(),
-    ))
-}
-
 pub fn publish_beacon_block_to_network<T: BeaconChainTypes + 'static>(
-    chan: NetworkChannel<T::EthSpec>,
+    chan: &NetworkChannel<T::EthSpec>,
    block: SignedBeaconBlock<T::EthSpec>,
 ) -> Result<(), ApiError> {
    // send the block via SSZ encoding
--- a/beacon_node/rest_api/src/lib.rs
+++ b/beacon_node/rest_api/src/lib.rs
@@ -1,22 +1,15 @@
 #[macro_use]
-mod macros;
-#[macro_use]
 extern crate lazy_static;
+mod router;
 extern crate network as client_network;

-mod advanced;
 mod beacon;
 pub mod config;
 mod consensus;
-mod error;
 mod helpers;
 mod lighthouse;
 mod metrics;
-mod network;
 mod node;
-mod response_builder;
-mod router;
-mod spec;
 mod url_query;
 mod validator;

@@ -24,7 +17,6 @@ use beacon_chain::{BeaconChain, BeaconChainTypes};
 use bus::Bus;
 use client_network::NetworkMessage;
 pub use config::ApiEncodingFormat;
-use error::{ApiError, ApiResult};
 use eth2_config::Eth2Config;
 use eth2_libp2p::NetworkGlobals;
 use futures::future::TryFutureExt;
@@ -32,6 +24,7 @@ use hyper::server::conn::AddrStream;
 use hyper::service::{make_service_fn, service_fn};
 use hyper::{Body, Request, Server};
 use parking_lot::Mutex;
+use rest_types::ApiError;
 use slog::{info, warn};
 use std::net::SocketAddr;
 use std::path::PathBuf;
@@ -42,6 +35,7 @@ use url_query::UrlQuery;

 pub use crate::helpers::parse_pubkey_bytes;
 pub use config::Config;
+pub use router::Context;

 pub type NetworkChannel<T> = mpsc::UnboundedSender<NetworkMessage<T>>;

@@ -63,36 +57,28 @@ pub fn start_server<T: BeaconChainTypes>(
    events: Arc<Mutex<Bus<SignedBeaconBlockHash>>>,
 ) -> Result<SocketAddr, hyper::Error> {
    let log = executor.log();
-    let inner_log = log.clone();
-    let rest_api_config = Arc::new(config.clone());
    let eth2_config = Arc::new(eth2_config);

+    let context = Arc::new(Context {
+        executor: executor.clone(),
+        config: config.clone(),
+        beacon_chain,
+        network_globals: network_info.network_globals.clone(),
+        network_chan: network_info.network_chan,
+        eth2_config,
+        log: log.clone(),
+        db_path,
+        freezer_db_path,
+        events,
+    });
+
    // Define the function that will build the request handler.
    let make_service = make_service_fn(move |_socket: &AddrStream| {
-        let beacon_chain = beacon_chain.clone();
-        let log = inner_log.clone();
-        let rest_api_config = rest_api_config.clone();
-        let eth2_config = eth2_config.clone();
-        let network_globals = network_info.network_globals.clone();
-        let network_channel = network_info.network_chan.clone();
-        let db_path = db_path.clone();
-        let freezer_db_path = freezer_db_path.clone();
-        let events = events.clone();
+        let ctx = context.clone();

        async move {
            Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| {
-                router::route(
-                    req,
-                    beacon_chain.clone(),
-                    network_globals.clone(),
-                    network_channel.clone(),
-                    rest_api_config.clone(),
-                    eth2_config.clone(),
-                    log.clone(),
-                    db_path.clone(),
-                    freezer_db_path.clone(),
-                    events.clone(),
-                )
+                router::on_http_request(req, ctx.clone())
            }))
        }
    });
--- a/beacon_node/rest_api/src/lighthouse.rs
+++ b/beacon_node/rest_api/src/lighthouse.rs
@@ -1,24 +1,16 @@
 //! This contains a collection of lighthouse specific HTTP endpoints.

-use crate::response_builder::ResponseBuilder;
-use crate::ApiResult;
-use eth2_libp2p::{NetworkGlobals, PeerInfo};
-use hyper::{Body, Request};
+use crate::{ApiError, Context};
+use beacon_chain::BeaconChainTypes;
+use eth2_libp2p::PeerInfo;
 use serde::Serialize;
 use std::sync::Arc;
 use types::EthSpec;

-/// The syncing state of the beacon node.
-pub fn syncing<T: EthSpec>(
-    req: Request<Body>,
-    network_globals: Arc<NetworkGlobals<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(&network_globals.sync_state())
-}
-
 /// Returns all known peers and corresponding information
-pub fn peers<T: EthSpec>(req: Request<Body>, network_globals: Arc<NetworkGlobals<T>>) -> ApiResult {
-    let peers: Vec<Peer<T>> = network_globals
+pub fn peers<T: BeaconChainTypes>(ctx: Arc<Context<T>>) -> Result<Vec<Peer<T::EthSpec>>, ApiError> {
+    Ok(ctx
+        .network_globals
        .peers
        .read()
        .peers()
@@ -26,16 +18,15 @@ pub fn peers<T: EthSpec>(req: Request<Body>, network_globals: Arc<NetworkGlobals
            peer_id: peer_id.to_string(),
            peer_info: peer_info.clone(),
        })
-        .collect();
-    ResponseBuilder::new(&req)?.body_no_ssz(&peers)
+        .collect())
 }

 /// Returns all known connected peers and their corresponding information
-pub fn connected_peers<T: EthSpec>(
-    req: Request<Body>,
-    network_globals: Arc<NetworkGlobals<T>>,
-) -> ApiResult {
-    let peers: Vec<Peer<T>> = network_globals
+pub fn connected_peers<T: BeaconChainTypes>(
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<Peer<T::EthSpec>>, ApiError> {
+    Ok(ctx
+        .network_globals
        .peers
        .read()
        .connected_peers()
@@ -43,14 +34,13 @@ pub fn connected_peers<T: EthSpec>(
            peer_id: peer_id.to_string(),
            peer_info: peer_info.clone(),
        })
-        .collect();
-    ResponseBuilder::new(&req)?.body_no_ssz(&peers)
+        .collect())
 }

 /// Information returned by `peers` and `connected_peers`.
 #[derive(Clone, Debug, Serialize)]
 #[serde(bound = "T: EthSpec")]
-struct Peer<T: EthSpec> {
+pub struct Peer<T: EthSpec> {
    /// The Peer's ID
    peer_id: String,
    /// The PeerInfo associated with the peer.
--- a/beacon_node/rest_api/src/macros.rs
+++ b/beacon_node/rest_api/src/macros.rs
@@ -1,11 +0,0 @@
-macro_rules! try_future {
-    ($expr:expr) => {
-        match $expr {
-            core::result::Result::Ok(val) => val,
-            core::result::Result::Err(err) => return Err(std::convert::From::from(err)),
-        }
-    };
-    ($expr:expr,) => {
-        $crate::try_future!($expr)
-    };
-}
--- a/beacon_node/rest_api/src/metrics.rs
+++ b/beacon_node/rest_api/src/metrics.rs
@@ -1,42 +1,38 @@
-use crate::response_builder::ResponseBuilder;
-use crate::{ApiError, ApiResult};
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use hyper::{Body, Request};
+use crate::{ApiError, Context};
+use beacon_chain::BeaconChainTypes;
 use lighthouse_metrics::{Encoder, TextEncoder};
 use rest_types::Health;
-use std::path::PathBuf;
 use std::sync::Arc;

 pub use lighthouse_metrics::*;

 lazy_static! {
+    pub static ref BEACON_HTTP_API_REQUESTS_TOTAL: Result<IntCounterVec> =
+        try_create_int_counter_vec(
+            "beacon_http_api_requests_total",
+            "Count of HTTP requests received",
+            &["endpoint"]
+        );
+    pub static ref BEACON_HTTP_API_SUCCESS_TOTAL: Result<IntCounterVec> =
+        try_create_int_counter_vec(
+            "beacon_http_api_success_total",
+            "Count of HTTP requests that returned 200 OK",
+            &["endpoint"]
+        );
+    pub static ref BEACON_HTTP_API_ERROR_TOTAL: Result<IntCounterVec> = try_create_int_counter_vec(
+        "beacon_http_api_error_total",
+        "Count of HTTP that did not return 200 OK",
+        &["endpoint"]
+    );
+    pub static ref BEACON_HTTP_API_TIMES_TOTAL: Result<HistogramVec> = try_create_histogram_vec(
+        "beacon_http_api_times_total",
+        "Duration to process HTTP requests",
+        &["endpoint"]
+    );
    pub static ref REQUEST_RESPONSE_TIME: Result<Histogram> = try_create_histogram(
        "http_server_request_duration_seconds",
        "Time taken to build a response to a HTTP request"
    );
-    pub static ref REQUEST_COUNT: Result<IntCounter> = try_create_int_counter(
-        "http_server_request_total",
-        "Total count of HTTP requests received"
-    );
-    pub static ref SUCCESS_COUNT: Result<IntCounter> = try_create_int_counter(
-        "http_server_success_total",
-        "Total count of HTTP 200 responses sent"
-    );
-    pub static ref VALIDATOR_GET_BLOCK_REQUEST_RESPONSE_TIME: Result<Histogram> =
-        try_create_histogram(
-            "http_server_validator_block_get_request_duration_seconds",
-            "Time taken to respond to GET /validator/block"
-        );
-    pub static ref VALIDATOR_GET_ATTESTATION_REQUEST_RESPONSE_TIME: Result<Histogram> =
-        try_create_histogram(
-            "http_server_validator_attestation_get_request_duration_seconds",
-            "Time taken to respond to GET /validator/attestation"
-        );
-    pub static ref VALIDATOR_GET_DUTIES_REQUEST_RESPONSE_TIME: Result<Histogram> =
-        try_create_histogram(
-            "http_server_validator_duties_get_request_duration_seconds",
-            "Time taken to respond to GET /validator/duties"
-        );
    pub static ref PROCESS_NUM_THREADS: Result<IntGauge> = try_create_int_gauge(
        "process_num_threads",
        "Number of threads used by the current process"
@@ -77,11 +73,8 @@ lazy_static! {
 ///
 /// This is a HTTP handler method.
 pub fn get_prometheus<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    db_path: PathBuf,
-    freezer_db_path: PathBuf,
-) -> ApiResult {
+    ctx: Arc<Context<T>>,
+) -> std::result::Result<String, ApiError> {
    let mut buffer = vec![];
    let encoder = TextEncoder::new();

@@ -101,9 +94,9 @@ pub fn get_prometheus<T: BeaconChainTypes>(
    // using `lighthouse_metrics::gather(..)` to collect the global `DEFAULT_REGISTRY` metrics into
    // a string that can be returned via HTTP.

-    slot_clock::scrape_for_metrics::<T::EthSpec, T::SlotClock>(&beacon_chain.slot_clock);
-    store::scrape_for_metrics(&db_path, &freezer_db_path);
-    beacon_chain::scrape_for_metrics(&beacon_chain);
+    slot_clock::scrape_for_metrics::<T::EthSpec, T::SlotClock>(&ctx.beacon_chain.slot_clock);
+    store::scrape_for_metrics(&ctx.db_path, &ctx.freezer_db_path);
+    beacon_chain::scrape_for_metrics(&ctx.beacon_chain);
    eth2_libp2p::scrape_discovery_metrics();

    // This will silently fail if we are unable to observe the health. This is desired behaviour
@@ -133,6 +126,5 @@ pub fn get_prometheus<T: BeaconChainTypes>(
        .unwrap();

    String::from_utf8(buffer)
-        .map(|string| ResponseBuilder::new(&req)?.body_text(string))
-        .map_err(|e| ApiError::ServerError(format!("Failed to encode prometheus info: {:?}", e)))?
+        .map_err(|e| ApiError::ServerError(format!("Failed to encode prometheus info: {:?}", e)))
 }
--- a/beacon_node/rest_api/src/network.rs
+++ b/beacon_node/rest_api/src/network.rs
@@ -1,72 +0,0 @@
-use crate::error::ApiResult;
-use crate::response_builder::ResponseBuilder;
-use crate::NetworkGlobals;
-use beacon_chain::BeaconChainTypes;
-use eth2_libp2p::{Multiaddr, PeerId};
-use hyper::{Body, Request};
-use std::sync::Arc;
-
-/// HTTP handler to return the list of libp2p multiaddr the client is listening on.
-///
-/// Returns a list of `Multiaddr`, serialized according to their `serde` impl.
-pub fn get_listen_addresses<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    let multiaddresses: Vec<Multiaddr> = network.listen_multiaddrs();
-    ResponseBuilder::new(&req)?.body_no_ssz(&multiaddresses)
-}
-
-/// HTTP handler to return the network port the client is listening on.
-///
-/// Returns the TCP port number in its plain form (which is also valid JSON serialization)
-pub fn get_listen_port<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&network.listen_port_tcp())
-}
-
-/// HTTP handler to return the Discv5 ENR from the client's libp2p service.
-///
-/// ENR is encoded as base64 string.
-pub fn get_enr<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(&network.local_enr().to_base64())
-}
-
-/// HTTP handler to return the `PeerId` from the client's libp2p service.
-///
-/// PeerId is encoded as base58 string.
-pub fn get_peer_id<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(&network.local_peer_id().to_base58())
-}
-
-/// HTTP handler to return the number of peers connected in the client's libp2p service.
-pub fn get_peer_count<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&network.connected_peers())
-}
-
-/// HTTP handler to return the list of peers connected to the client's libp2p service.
-///
-/// Peers are presented as a list of `PeerId::to_string()`.
-pub fn get_peer_list<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T::EthSpec>>,
-) -> ApiResult {
-    let connected_peers: Vec<String> = network
-        .peers
-        .read()
-        .connected_peer_ids()
-        .map(PeerId::to_string)
-        .collect();
-    ResponseBuilder::new(&req)?.body_no_ssz(&connected_peers)
-}
--- a/beacon_node/rest_api/src/node.rs
+++ b/beacon_node/rest_api/src/node.rs
@@ -1,23 +1,19 @@
-use crate::response_builder::ResponseBuilder;
-use crate::{ApiError, ApiResult};
-use eth2_libp2p::{types::SyncState, NetworkGlobals};
-use hyper::{Body, Request};
-use lighthouse_version::version_with_platform;
-use rest_types::{Health, SyncingResponse, SyncingStatus};
+use crate::{ApiError, Context};
+use beacon_chain::BeaconChainTypes;
+use eth2_libp2p::types::SyncState;
+use rest_types::{SyncingResponse, SyncingStatus};
 use std::sync::Arc;
-use types::{EthSpec, Slot};
+use types::Slot;

-/// Read the version string from the current Lighthouse build.
-pub fn get_version(req: Request<Body>) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(&version_with_platform())
-}
+/// Returns a syncing status.
+pub fn syncing<T: BeaconChainTypes>(ctx: Arc<Context<T>>) -> Result<SyncingResponse, ApiError> {
+    let current_slot = ctx
+        .beacon_chain
+        .head_info()
+        .map_err(|e| ApiError::ServerError(format!("Unable to read head slot: {:?}", e)))?
+        .slot;

-pub fn syncing<T: EthSpec>(
-    req: Request<Body>,
-    network: Arc<NetworkGlobals<T>>,
-    current_slot: Slot,
-) -> ApiResult {
-    let (starting_slot, highest_slot) = match network.sync_state() {
+    let (starting_slot, highest_slot) = match ctx.network_globals.sync_state() {
        SyncState::SyncingFinalized {
            start_slot,
            head_slot,
@@ -36,14 +32,8 @@ pub fn syncing<T: EthSpec>(
        highest_slot,
    };

-    ResponseBuilder::new(&req)?.body(&SyncingResponse {
-        is_syncing: network.is_syncing(),
+    Ok(SyncingResponse {
+        is_syncing: ctx.network_globals.is_syncing(),
        sync_status,
    })
 }
-
-pub fn get_health(req: Request<Body>) -> ApiResult {
-    let health = Health::observe().map_err(ApiError::ServerError)?;
-
-    ResponseBuilder::new(&req)?.body_no_ssz(&health)
-}
--- a/beacon_node/rest_api/src/response_builder.rs
+++ b/beacon_node/rest_api/src/response_builder.rs
@@ -1,83 +0,0 @@
-use super::{ApiError, ApiResult};
-use crate::config::ApiEncodingFormat;
-use hyper::header;
-use hyper::{Body, Request, Response, StatusCode};
-use serde::Serialize;
-use ssz::Encode;
-
-pub struct ResponseBuilder {
-    encoding: ApiEncodingFormat,
-}
-
-impl ResponseBuilder {
-    pub fn new(req: &Request<Body>) -> Result<Self, ApiError> {
-        let accept_header: String = req
-            .headers()
-            .get(header::ACCEPT)
-            .map_or(Ok(""), |h| h.to_str())
-            .map_err(|e| {
-                ApiError::BadRequest(format!(
-                    "The Accept header contains invalid characters: {:?}",
-                    e
-                ))
-            })
-            .map(String::from)?;
-
-        // JSON is our default encoding, unless something else is requested.
-        let encoding = ApiEncodingFormat::from(accept_header.as_str());
-        Ok(Self { encoding })
-    }
-
-    pub fn body<T: Serialize + Encode>(self, item: &T) -> ApiResult {
-        match self.encoding {
-            ApiEncodingFormat::SSZ => Response::builder()
-                .status(StatusCode::OK)
-                .header("content-type", "application/ssz")
-                .body(Body::from(item.as_ssz_bytes()))
-                .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e))),
-            _ => self.body_no_ssz(item),
-        }
-    }
-
-    pub fn body_no_ssz<T: Serialize>(self, item: &T) -> ApiResult {
-        let (body, content_type) = match self.encoding {
-            ApiEncodingFormat::JSON => (
-                Body::from(serde_json::to_string(&item).map_err(|e| {
-                    ApiError::ServerError(format!(
-                        "Unable to serialize response body as JSON: {:?}",
-                        e
-                    ))
-                })?),
-                "application/json",
-            ),
-            ApiEncodingFormat::SSZ => {
-                return Err(ApiError::UnsupportedType(
-                    "Response cannot be encoded as SSZ.".into(),
-                ));
-            }
-            ApiEncodingFormat::YAML => (
-                Body::from(serde_yaml::to_string(&item).map_err(|e| {
-                    ApiError::ServerError(format!(
-                        "Unable to serialize response body as YAML: {:?}",
-                        e
-                    ))
-                })?),
-                "application/yaml",
-            ),
-        };
-
-        Response::builder()
-            .status(StatusCode::OK)
-            .header("content-type", content_type)
-            .body(body)
-            .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))
-    }
-
-    pub fn body_text(self, text: String) -> ApiResult {
-        Response::builder()
-            .status(StatusCode::OK)
-            .header("content-type", "text/plain; charset=utf-8")
-            .body(Body::from(text))
-            .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))
-    }
-}
--- a/beacon_node/rest_api/src/router.rs
+++ b/beacon_node/rest_api/src/router.rs
@@ -1,241 +1,322 @@
 use crate::{
-    advanced, beacon, config::Config, consensus, error::ApiError, helpers, lighthouse, metrics,
-    network, node, spec, validator, NetworkChannel,
+    beacon, config::Config, consensus, lighthouse, metrics, node, validator, NetworkChannel,
 };
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use bus::Bus;
+use environment::TaskExecutor;
 use eth2_config::Eth2Config;
-use eth2_libp2p::NetworkGlobals;
+use eth2_libp2p::{NetworkGlobals, PeerId};
 use hyper::header::HeaderValue;
 use hyper::{Body, Method, Request, Response};
+use lighthouse_version::version_with_platform;
+use operation_pool::PersistedOperationPool;
 use parking_lot::Mutex;
+use rest_types::{ApiError, Handler, Health};
 use slog::debug;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Instant;
-use types::{SignedBeaconBlockHash, Slot};
+use types::{EthSpec, SignedBeaconBlockHash};

-// Allowing more than 7 arguments.
-#[allow(clippy::too_many_arguments)]
-pub async fn route<T: BeaconChainTypes>(
+pub struct Context<T: BeaconChainTypes> {
+    pub executor: TaskExecutor,
+    pub config: Config,
+    pub beacon_chain: Arc<BeaconChain<T>>,
+    pub network_globals: Arc<NetworkGlobals<T::EthSpec>>,
+    pub network_chan: NetworkChannel<T::EthSpec>,
+    pub eth2_config: Arc<Eth2Config>,
+    pub log: slog::Logger,
+    pub db_path: PathBuf,
+    pub freezer_db_path: PathBuf,
+    pub events: Arc<Mutex<Bus<SignedBeaconBlockHash>>>,
+}
+
+pub async fn on_http_request<T: BeaconChainTypes>(
    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    network_globals: Arc<NetworkGlobals<T::EthSpec>>,
-    network_channel: NetworkChannel<T::EthSpec>,
-    rest_api_config: Arc<Config>,
-    eth2_config: Arc<Eth2Config>,
-    local_log: slog::Logger,
-    db_path: PathBuf,
-    freezer_db_path: PathBuf,
-    events: Arc<Mutex<Bus<SignedBeaconBlockHash>>>,
+    ctx: Arc<Context<T>>,
 ) -> Result<Response<Body>, ApiError> {
-    metrics::inc_counter(&metrics::REQUEST_COUNT);
-    let received_instant = Instant::now();
-
    let path = req.uri().path().to_string();

-    let log = local_log.clone();
-    let result = {
-        let _timer = metrics::start_timer(&metrics::REQUEST_RESPONSE_TIME);
+    let _timer = metrics::start_timer_vec(&metrics::BEACON_HTTP_API_TIMES_TOTAL, &[&path]);
+    metrics::inc_counter_vec(&metrics::BEACON_HTTP_API_REQUESTS_TOTAL, &[&path]);

-        match (req.method(), path.as_ref()) {
-            // Methods for Client
-            (&Method::GET, "/node/health") => node::get_health(req),
-            (&Method::GET, "/node/version") => node::get_version(req),
-            (&Method::GET, "/node/syncing") => {
-                // inform the current slot, or set to 0
-                let current_slot = beacon_chain
-                    .head_info()
-                    .map(|info| info.slot)
-                    .unwrap_or_else(|_| Slot::from(0u64));
+    let received_instant = Instant::now();
+    let log = ctx.log.clone();
+    let allow_origin = ctx.config.allow_origin.clone();

-                node::syncing::<T::EthSpec>(req, network_globals, current_slot)
-            }
-
-            // Methods for Network
-            (&Method::GET, "/network/enr") => network::get_enr::<T>(req, network_globals),
-            (&Method::GET, "/network/peer_count") => {
-                network::get_peer_count::<T>(req, network_globals)
-            }
-            (&Method::GET, "/network/peer_id") => network::get_peer_id::<T>(req, network_globals),
-            (&Method::GET, "/network/peers") => network::get_peer_list::<T>(req, network_globals),
-            (&Method::GET, "/network/listen_port") => {
-                network::get_listen_port::<T>(req, network_globals)
-            }
-            (&Method::GET, "/network/listen_addresses") => {
-                network::get_listen_addresses::<T>(req, network_globals)
-            }
-
-            // Methods for Beacon Node
-            (&Method::GET, "/beacon/head") => beacon::get_head::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/heads") => beacon::get_heads::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/block") => beacon::get_block::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/block_root") => beacon::get_block_root::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/fork") => beacon::get_fork::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/fork/stream") => {
-                let reader = events.lock().add_rx();
-                beacon::stream_forks::<T>(log, reader)
-            }
-            (&Method::GET, "/beacon/genesis_time") => {
-                beacon::get_genesis_time::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/beacon/genesis_validators_root") => {
-                beacon::get_genesis_validators_root::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/beacon/validators") => beacon::get_validators::<T>(req, beacon_chain),
-            (&Method::POST, "/beacon/validators") => {
-                beacon::post_validators::<T>(req, beacon_chain).await
-            }
-            (&Method::GET, "/beacon/validators/all") => {
-                beacon::get_all_validators::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/beacon/validators/active") => {
-                beacon::get_active_validators::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/beacon/state") => beacon::get_state::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/state_root") => beacon::get_state_root::<T>(req, beacon_chain),
-            (&Method::GET, "/beacon/state/genesis") => {
-                beacon::get_genesis_state::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/beacon/committees") => beacon::get_committees::<T>(req, beacon_chain),
-            (&Method::POST, "/beacon/proposer_slashing") => {
-                beacon::proposer_slashing::<T>(req, beacon_chain).await
-            }
-            (&Method::POST, "/beacon/attester_slashing") => {
-                beacon::attester_slashing::<T>(req, beacon_chain).await
-            }
-
-            // Methods for Validator
-            (&Method::POST, "/validator/duties") => {
-                let timer =
-                    metrics::start_timer(&metrics::VALIDATOR_GET_DUTIES_REQUEST_RESPONSE_TIME);
-                let response = validator::post_validator_duties::<T>(req, beacon_chain);
-                drop(timer);
-                response.await
-            }
-            (&Method::POST, "/validator/subscribe") => {
-                validator::post_validator_subscriptions::<T>(req, network_channel).await
-            }
-            (&Method::GET, "/validator/duties/all") => {
-                validator::get_all_validator_duties::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/validator/duties/active") => {
-                validator::get_active_validator_duties::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/validator/block") => {
-                let timer =
-                    metrics::start_timer(&metrics::VALIDATOR_GET_BLOCK_REQUEST_RESPONSE_TIME);
-                let response = validator::get_new_beacon_block::<T>(req, beacon_chain, log);
-                drop(timer);
-                response
-            }
-            (&Method::POST, "/validator/block") => {
-                validator::publish_beacon_block::<T>(req, beacon_chain, network_channel, log).await
-            }
-            (&Method::GET, "/validator/attestation") => {
-                let timer =
-                    metrics::start_timer(&metrics::VALIDATOR_GET_ATTESTATION_REQUEST_RESPONSE_TIME);
-                let response = validator::get_new_attestation::<T>(req, beacon_chain);
-                drop(timer);
-                response
-            }
-            (&Method::GET, "/validator/aggregate_attestation") => {
-                validator::get_aggregate_attestation::<T>(req, beacon_chain)
-            }
-            (&Method::POST, "/validator/attestations") => {
-                validator::publish_attestations::<T>(req, beacon_chain, network_channel, log).await
-            }
-            (&Method::POST, "/validator/aggregate_and_proofs") => {
-                validator::publish_aggregate_and_proofs::<T>(
-                    req,
-                    beacon_chain,
-                    network_channel,
-                    log,
-                )
-                .await
-            }
-
-            // Methods for consensus
-            (&Method::GET, "/consensus/global_votes") => {
-                consensus::get_vote_count::<T>(req, beacon_chain)
-            }
-            (&Method::POST, "/consensus/individual_votes") => {
-                consensus::post_individual_votes::<T>(req, beacon_chain).await
-            }
-
-            // Methods for bootstrap and checking configuration
-            (&Method::GET, "/spec") => spec::get_spec::<T>(req, beacon_chain),
-            (&Method::GET, "/spec/slots_per_epoch") => spec::get_slots_per_epoch::<T>(req),
-            (&Method::GET, "/spec/deposit_contract") => {
-                helpers::implementation_pending_response(req)
-            }
-            (&Method::GET, "/spec/eth2_config") => spec::get_eth2_config::<T>(req, eth2_config),
-
-            // Methods for advanced parameters
-            (&Method::GET, "/advanced/fork_choice") => {
-                advanced::get_fork_choice::<T>(req, beacon_chain)
-            }
-            (&Method::GET, "/advanced/operation_pool") => {
-                advanced::get_operation_pool::<T>(req, beacon_chain)
-            }
-
-            (&Method::GET, "/metrics") => {
-                metrics::get_prometheus::<T>(req, beacon_chain, db_path, freezer_db_path)
-            }
-
-            // Lighthouse specific
-            (&Method::GET, "/lighthouse/syncing") => {
-                lighthouse::syncing::<T::EthSpec>(req, network_globals)
-            }
-
-            (&Method::GET, "/lighthouse/peers") => {
-                lighthouse::peers::<T::EthSpec>(req, network_globals)
-            }
-
-            (&Method::GET, "/lighthouse/connected_peers") => {
-                lighthouse::connected_peers::<T::EthSpec>(req, network_globals)
-            }
-            _ => Err(ApiError::NotFound(
-                "Request path and/or method not found.".to_owned(),
-            )),
-        }
-    };
-
-    let request_processing_duration = Instant::now().duration_since(received_instant);
-
-    // Map the Rust-friendly `Result` in to a http-friendly response. In effect, this ensures that
-    // any `Err` returned from our response handlers becomes a valid http response to the client
-    // (e.g., a response with a 404 or 500 status).
-
-    match result {
+    match route(req, ctx).await {
        Ok(mut response) => {
-            if rest_api_config.allow_origin != "" {
+            metrics::inc_counter_vec(&metrics::BEACON_HTTP_API_SUCCESS_TOTAL, &[&path]);
+
+            if allow_origin != "" {
                let headers = response.headers_mut();
                headers.insert(
                    hyper::header::ACCESS_CONTROL_ALLOW_ORIGIN,
-                    HeaderValue::from_str(&rest_api_config.allow_origin)?,
+                    HeaderValue::from_str(&allow_origin)?,
                );
                headers.insert(hyper::header::VARY, HeaderValue::from_static("Origin"));
            }

            debug!(
-                local_log,
+                log,
                "HTTP API request successful";
                "path" => path,
-                "duration_ms" => request_processing_duration.as_millis()
+                "duration_ms" => Instant::now().duration_since(received_instant).as_millis()
            );
-            metrics::inc_counter(&metrics::SUCCESS_COUNT);
            Ok(response)
        }

        Err(error) => {
+            metrics::inc_counter_vec(&metrics::BEACON_HTTP_API_ERROR_TOTAL, &[&path]);
+
            debug!(
-                local_log,
+                log,
                "HTTP API request failure";
                "path" => path,
-                "duration_ms" => request_processing_duration.as_millis()
+                "duration_ms" => Instant::now().duration_since(received_instant).as_millis()
            );
            Ok(error.into())
        }
    }
 }
+
+async fn route<T: BeaconChainTypes>(
+    req: Request<Body>,
+    ctx: Arc<Context<T>>,
+) -> Result<Response<Body>, ApiError> {
+    let path = req.uri().path().to_string();
+    let ctx = ctx.clone();
+    let method = req.method().clone();
+    let executor = ctx.executor.clone();
+    let handler = Handler::new(req, ctx, executor)?;
+
+    match (method, path.as_ref()) {
+        (Method::GET, "/node/version") => handler
+            .static_value(version_with_platform())
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/node/health") => handler
+            .static_value(Health::observe().map_err(ApiError::ServerError)?)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/node/syncing") => handler
+            .allow_body()
+            .in_blocking_task(|_, ctx| node::syncing(ctx))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/enr") => handler
+            .in_core_task(|_, ctx| Ok(ctx.network_globals.local_enr().to_base64()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/peer_count") => handler
+            .in_core_task(|_, ctx| Ok(ctx.network_globals.connected_peers()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/peer_id") => handler
+            .in_core_task(|_, ctx| Ok(ctx.network_globals.local_peer_id().to_base58()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/peers") => handler
+            .in_blocking_task(|_, ctx| {
+                Ok(ctx
+                    .network_globals
+                    .peers
+                    .read()
+                    .connected_peer_ids()
+                    .map(PeerId::to_string)
+                    .collect::<Vec<_>>())
+            })
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/listen_port") => handler
+            .in_core_task(|_, ctx| Ok(ctx.network_globals.listen_port_tcp()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/network/listen_addresses") => handler
+            .in_blocking_task(|_, ctx| Ok(ctx.network_globals.listen_multiaddrs()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/beacon/head") => handler
+            .in_blocking_task(|_, ctx| beacon::get_head(ctx))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/heads") => handler
+            .in_blocking_task(|_, ctx| Ok(beacon::get_heads(ctx)))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/block") => handler
+            .in_blocking_task(beacon::get_block)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/block_root") => handler
+            .in_blocking_task(beacon::get_block_root)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/fork") => handler
+            .in_blocking_task(|_, ctx| Ok(ctx.beacon_chain.head_info()?.fork))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/fork/stream") => {
+            handler.sse_stream(|_, ctx| beacon::stream_forks(ctx)).await
+        }
+        (Method::GET, "/beacon/genesis_time") => handler
+            .in_blocking_task(|_, ctx| Ok(ctx.beacon_chain.head_info()?.genesis_time))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/genesis_validators_root") => handler
+            .in_blocking_task(|_, ctx| Ok(ctx.beacon_chain.head_info()?.genesis_validators_root))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/validators") => handler
+            .in_blocking_task(beacon::get_validators)
+            .await?
+            .all_encodings(),
+        (Method::POST, "/beacon/validators") => handler
+            .allow_body()
+            .in_blocking_task(beacon::post_validators)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/validators/all") => handler
+            .in_blocking_task(beacon::get_all_validators)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/validators/active") => handler
+            .in_blocking_task(beacon::get_active_validators)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/state") => handler
+            .in_blocking_task(beacon::get_state)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/state_root") => handler
+            .in_blocking_task(beacon::get_state_root)
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/state/genesis") => handler
+            .in_blocking_task(|_, ctx| beacon::get_genesis_state(ctx))
+            .await?
+            .all_encodings(),
+        (Method::GET, "/beacon/committees") => handler
+            .in_blocking_task(beacon::get_committees)
+            .await?
+            .all_encodings(),
+        (Method::POST, "/beacon/proposer_slashing") => handler
+            .allow_body()
+            .in_blocking_task(beacon::proposer_slashing)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/beacon/attester_slashing") => handler
+            .allow_body()
+            .in_blocking_task(beacon::attester_slashing)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/validator/duties") => handler
+            .allow_body()
+            .in_blocking_task(validator::post_validator_duties)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/validator/subscribe") => handler
+            .allow_body()
+            .in_blocking_task(validator::post_validator_subscriptions)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/validator/duties/all") => handler
+            .in_blocking_task(validator::get_all_validator_duties)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/validator/duties/active") => handler
+            .in_blocking_task(validator::get_active_validator_duties)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/validator/block") => handler
+            .in_blocking_task(validator::get_new_beacon_block)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/validator/block") => handler
+            .allow_body()
+            .in_blocking_task(validator::publish_beacon_block)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/validator/attestation") => handler
+            .in_blocking_task(validator::get_new_attestation)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/validator/aggregate_attestation") => handler
+            .in_blocking_task(validator::get_aggregate_attestation)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/validator/attestations") => handler
+            .allow_body()
+            .in_blocking_task(validator::publish_attestations)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/validator/aggregate_and_proofs") => handler
+            .allow_body()
+            .in_blocking_task(validator::publish_aggregate_and_proofs)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/consensus/global_votes") => handler
+            .allow_body()
+            .in_blocking_task(consensus::get_vote_count)
+            .await?
+            .serde_encodings(),
+        (Method::POST, "/consensus/individual_votes") => handler
+            .allow_body()
+            .in_blocking_task(consensus::post_individual_votes)
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/spec") => handler
+            // TODO: this clone is not ideal.
+            .in_blocking_task(|_, ctx| Ok(ctx.beacon_chain.spec.clone()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/spec/slots_per_epoch") => handler
+            .static_value(T::EthSpec::slots_per_epoch())
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/spec/eth2_config") => handler
+            // TODO: this clone is not ideal.
+            .in_blocking_task(|_, ctx| Ok(ctx.eth2_config.as_ref().clone()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/advanced/fork_choice") => handler
+            .in_blocking_task(|_, ctx| {
+                Ok(ctx
+                    .beacon_chain
+                    .fork_choice
+                    .read()
+                    .proto_array()
+                    .core_proto_array()
+                    .clone())
+            })
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/advanced/operation_pool") => handler
+            .in_blocking_task(|_, ctx| {
+                Ok(PersistedOperationPool::from_operation_pool(
+                    &ctx.beacon_chain.op_pool,
+                ))
+            })
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/metrics") => handler
+            .in_blocking_task(|_, ctx| metrics::get_prometheus(ctx))
+            .await?
+            .text_encoding(),
+        (Method::GET, "/lighthouse/syncing") => handler
+            .in_blocking_task(|_, ctx| Ok(ctx.network_globals.sync_state()))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/lighthouse/peers") => handler
+            .in_blocking_task(|_, ctx| lighthouse::peers(ctx))
+            .await?
+            .serde_encodings(),
+        (Method::GET, "/lighthouse/connected_peers") => handler
+            .in_blocking_task(|_, ctx| lighthouse::connected_peers(ctx))
+            .await?
+            .serde_encodings(),
+        _ => Err(ApiError::NotFound(
+            "Request path and/or method not found.".to_owned(),
+        )),
+    }
+}
--- a/beacon_node/rest_api/src/spec.rs
+++ b/beacon_node/rest_api/src/spec.rs
@@ -1,28 +0,0 @@
-use super::ApiResult;
-use crate::response_builder::ResponseBuilder;
-use beacon_chain::{BeaconChain, BeaconChainTypes};
-use eth2_config::Eth2Config;
-use hyper::{Body, Request};
-use std::sync::Arc;
-use types::EthSpec;
-
-/// HTTP handler to return the full spec object.
-pub fn get_spec<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(&beacon_chain.spec)
-}
-
-/// HTTP handler to return the full Eth2Config object.
-pub fn get_eth2_config<T: BeaconChainTypes>(
-    req: Request<Body>,
-    eth2_config: Arc<Eth2Config>,
-) -> ApiResult {
-    ResponseBuilder::new(&req)?.body_no_ssz(eth2_config.as_ref())
-}
-
-/// HTTP handler to return the full spec object.
-pub fn get_slots_per_epoch<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
-    ResponseBuilder::new(&req)?.body(&T::EthSpec::slots_per_epoch())
-}
--- a/beacon_node/rest_api/src/validator.rs
+++ b/beacon_node/rest_api/src/validator.rs
@@ -1,41 +1,32 @@
-use crate::helpers::{
-    check_content_type_for_json, parse_hex_ssz_bytes, publish_beacon_block_to_network,
-};
-use crate::response_builder::ResponseBuilder;
-use crate::{ApiError, ApiResult, NetworkChannel, UrlQuery};
+use crate::helpers::{parse_hex_ssz_bytes, publish_beacon_block_to_network};
+use crate::{ApiError, Context, NetworkChannel, UrlQuery};
 use beacon_chain::{
    attestation_verification::Error as AttnError, BeaconChain, BeaconChainError, BeaconChainTypes,
    BlockError, ForkChoiceError, StateSkipConfig,
 };
 use bls::PublicKeyBytes;
 use eth2_libp2p::PubsubMessage;
-use hyper::{Body, Request};
+use hyper::Request;
 use network::NetworkMessage;
-use rayon::prelude::*;
 use rest_types::{ValidatorDutiesRequest, ValidatorDutyBytes, ValidatorSubscription};
 use slog::{error, info, trace, warn, Logger};
 use std::sync::Arc;
 use types::beacon_state::EthSpec;
 use types::{
-    Attestation, AttestationData, BeaconState, Epoch, RelativeEpoch, SelectionProof,
+    Attestation, AttestationData, BeaconBlock, BeaconState, Epoch, RelativeEpoch, SelectionProof,
    SignedAggregateAndProof, SignedBeaconBlock, SubnetId,
 };

 /// HTTP Handler to retrieve the duties for a set of validators during a particular epoch. This
 /// method allows for collecting bulk sets of validator duties without risking exceeding the max
 /// URL length with query pairs.
-pub async fn post_validator_duties<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn post_validator_duties<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorDutyBytes>, ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;

-    serde_json::from_slice::<ValidatorDutiesRequest>(&chunks)
+    serde_json::from_slice::<ValidatorDutiesRequest>(&body)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to parse JSON into ValidatorDutiesRequest: {:?}",
@@ -44,29 +35,22 @@ pub async fn post_validator_duties<T: BeaconChainTypes>(
        })
        .and_then(|bulk_request| {
            return_validator_duties(
-                beacon_chain,
+                &ctx.beacon_chain.clone(),
                bulk_request.epoch,
                bulk_request.pubkeys.into_iter().map(Into::into).collect(),
            )
        })
-        .and_then(|duties| response_builder?.body_no_ssz(&duties))
 }

 /// HTTP Handler to retrieve subscriptions for a set of validators. This allows the node to
 /// organise peer discovery and topic subscription for known validators.
-pub async fn post_validator_subscriptions<T: BeaconChainTypes>(
-    req: Request<Body>,
-    network_chan: NetworkChannel<T::EthSpec>,
-) -> ApiResult {
-    try_future!(check_content_type_for_json(&req));
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn post_validator_subscriptions<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<(), ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;

-    serde_json::from_slice(&chunks)
+    serde_json::from_slice(&body)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to parse JSON into ValidatorSubscriptions: {:?}",
@@ -74,7 +58,7 @@ pub async fn post_validator_subscriptions<T: BeaconChainTypes>(
            ))
        })
        .and_then(move |subscriptions: Vec<ValidatorSubscription>| {
-            network_chan
+            ctx.network_chan
                .send(NetworkMessage::Subscribe { subscriptions })
                .map_err(|e| {
                    ApiError::ServerError(format!(
@@ -84,19 +68,18 @@ pub async fn post_validator_subscriptions<T: BeaconChainTypes>(
                })?;
            Ok(())
        })
-        .and_then(|_| response_builder?.body_no_ssz(&()))
 }

 /// HTTP Handler to retrieve all validator duties for the given epoch.
 pub fn get_all_validator_duties<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorDutyBytes>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let epoch = query.epoch()?;

-    let state = get_state_for_epoch(&beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;
+    let state = get_state_for_epoch(&ctx.beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;

    let validator_pubkeys = state
        .validators
@@ -104,21 +87,19 @@ pub fn get_all_validator_duties<T: BeaconChainTypes>(
        .map(|validator| validator.pubkey.clone())
        .collect();

-    let duties = return_validator_duties(beacon_chain, epoch, validator_pubkeys)?;
-
-    ResponseBuilder::new(&req)?.body_no_ssz(&duties)
+    return_validator_duties(&ctx.beacon_chain, epoch, validator_pubkeys)
 }

 /// HTTP Handler to retrieve all active validator duties for the given epoch.
 pub fn get_active_validator_duties<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Vec<ValidatorDutyBytes>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let epoch = query.epoch()?;

-    let state = get_state_for_epoch(&beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;
+    let state = get_state_for_epoch(&ctx.beacon_chain, epoch, StateSkipConfig::WithoutStateRoots)?;

    let validator_pubkeys = state
        .validators
@@ -127,9 +108,7 @@ pub fn get_active_validator_duties<T: BeaconChainTypes>(
        .map(|validator| validator.pubkey.clone())
        .collect();

-    let duties = return_validator_duties(beacon_chain, epoch, validator_pubkeys)?;
-
-    ResponseBuilder::new(&req)?.body_no_ssz(&duties)
+    return_validator_duties(&ctx.beacon_chain, epoch, validator_pubkeys)
 }

 /// Helper function to return the state that can be used to determine the duties for some `epoch`.
@@ -165,7 +144,7 @@ pub fn get_state_for_epoch<T: BeaconChainTypes>(

 /// Helper function to get the duties for some `validator_pubkeys` in some `epoch`.
 fn return_validator_duties<T: BeaconChainTypes>(
-    beacon_chain: Arc<BeaconChain<T>>,
+    beacon_chain: &BeaconChain<T>,
    epoch: Epoch,
    validator_pubkeys: Vec<PublicKeyBytes>,
 ) -> Result<Vec<ValidatorDutyBytes>, ApiError> {
@@ -281,10 +260,9 @@ fn return_validator_duties<T: BeaconChainTypes>(

 /// HTTP Handler to produce a new BeaconBlock from the current state, ready to be signed by a validator.
 pub fn get_new_beacon_block<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    log: Logger,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<BeaconBlock<T::EthSpec>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let slot = query.slot()?;
@@ -296,11 +274,12 @@ pub fn get_new_beacon_block<T: BeaconChainTypes>(
        None
    };

-    let (new_block, _state) = beacon_chain
+    let (new_block, _state) = ctx
+        .beacon_chain
        .produce_block(randao_reveal, slot, validator_graffiti)
        .map_err(|e| {
            error!(
-                log,
+                ctx.log,
                "Error whilst producing block";
                "error" => format!("{:?}", e)
            );
@@ -311,48 +290,40 @@ pub fn get_new_beacon_block<T: BeaconChainTypes>(
            ))
        })?;

-    ResponseBuilder::new(&req)?.body(&new_block)
+    Ok(new_block)
 }

 /// HTTP Handler to publish a SignedBeaconBlock, which has been signed by a validator.
-pub async fn publish_beacon_block<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    network_chan: NetworkChannel<T::EthSpec>,
-    log: Logger,
-) -> ApiResult {
-    try_future!(check_content_type_for_json(&req));
-    let response_builder = ResponseBuilder::new(&req);
-
+pub fn publish_beacon_block<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<(), ApiError> {
    let body = req.into_body();
-    let chunks = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;

-    serde_json::from_slice(&chunks).map_err(|e| {
+    serde_json::from_slice(&body).map_err(|e| {
                    ApiError::BadRequest(format!("Unable to parse JSON into SignedBeaconBlock: {:?}", e))
                })
            .and_then(move |block: SignedBeaconBlock<T::EthSpec>| {
                let slot = block.slot();
-                match beacon_chain.process_block(block.clone()) {
+                match ctx.beacon_chain.process_block(block.clone()) {
                    Ok(block_root) => {
                        // Block was processed, publish via gossipsub
                        info!(
-                            log,
+                            ctx.log,
                            "Block from local validator";
                            "block_root" => format!("{}", block_root),
                            "block_slot" => slot,
                        );

-                        publish_beacon_block_to_network::<T>(network_chan, block)?;
+                        publish_beacon_block_to_network::<T>(&ctx.network_chan, block)?;

                        // Run the fork choice algorithm and enshrine a new canonical head, if
                        // found.
                        //
                        // The new head may or may not be the block we just received.
-                        if let Err(e) = beacon_chain.fork_choice() {
+                        if let Err(e) = ctx.beacon_chain.fork_choice() {
                            error!(
-                                log,
+                                ctx.log,
                                "Failed to find beacon chain head";
                                "error" => format!("{:?}", e)
                            );
@@ -366,9 +337,9 @@ pub async fn publish_beacon_block<T: BeaconChainTypes>(
                            // - Excessive time between block produce and publish.
                            // - A validator is using another beacon node to produce blocks and
                            // submitting them here.
-                            if beacon_chain.head()?.beacon_block_root != block_root {
+                            if ctx.beacon_chain.head()?.beacon_block_root != block_root {
                                warn!(
-                                    log,
+                                    ctx.log,
                                    "Block from validator is not head";
                                    "desc" => "potential re-org",
                                );
@@ -380,7 +351,7 @@ pub async fn publish_beacon_block<T: BeaconChainTypes>(
                    }
                    Err(BlockError::BeaconChainError(e)) => {
                        error!(
-                            log,
+                            ctx.log,
                            "Error whilst processing block";
                            "error" => format!("{:?}", e)
                        );
@@ -392,7 +363,7 @@ pub async fn publish_beacon_block<T: BeaconChainTypes>(
                    }
                    Err(other) => {
                        warn!(
-                            log,
+                            ctx.log,
                            "Invalid block from local validator";
                            "outcome" => format!("{:?}", other)
                        );
@@ -404,41 +375,41 @@ pub async fn publish_beacon_block<T: BeaconChainTypes>(
                    }
                }
        })
-        .and_then(|_| response_builder?.body_no_ssz(&()))
 }

 /// HTTP Handler to produce a new Attestation from the current state, ready to be signed by a validator.
 pub fn get_new_attestation<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Attestation<T::EthSpec>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let slot = query.slot()?;
    let index = query.committee_index()?;

-    let attestation = beacon_chain
+    ctx.beacon_chain
        .produce_unaggregated_attestation(slot, index)
-        .map_err(|e| ApiError::BadRequest(format!("Unable to produce attestation: {:?}", e)))?;
-
-    ResponseBuilder::new(&req)?.body(&attestation)
+        .map_err(|e| ApiError::BadRequest(format!("Unable to produce attestation: {:?}", e)))
 }

 /// HTTP Handler to retrieve the aggregate attestation for a slot
 pub fn get_aggregate_attestation<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-) -> ApiResult {
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<Attestation<T::EthSpec>, ApiError> {
    let query = UrlQuery::from_request(&req)?;

    let attestation_data = query.attestation_data()?;

-    match beacon_chain.get_aggregated_attestation(&attestation_data) {
-        Ok(Some(attestation)) => ResponseBuilder::new(&req)?.body(&attestation),
+    match ctx
+        .beacon_chain
+        .get_aggregated_attestation(&attestation_data)
+    {
+        Ok(Some(attestation)) => Ok(attestation),
        Ok(None) => Err(ApiError::NotFound(format!(
            "No matching aggregate attestation for slot {:?} is known in slot {:?}",
            attestation_data.slot,
-            beacon_chain.slot()
+            ctx.beacon_chain.slot()
        ))),
        Err(e) => Err(ApiError::ServerError(format!(
            "Unable to obtain attestation: {:?}",
@@ -448,22 +419,13 @@ pub fn get_aggregate_attestation<T: BeaconChainTypes>(
 }

 /// HTTP Handler to publish a list of Attestations, which have been signed by a number of validators.
-pub async fn publish_attestations<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    network_chan: NetworkChannel<T::EthSpec>,
-    log: Logger,
-) -> ApiResult {
-    try_future!(check_content_type_for_json(&req));
-    let response_builder = ResponseBuilder::new(&req);
+pub fn publish_attestations<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<(), ApiError> {
+    let bytes = req.into_body();

-    let body = req.into_body();
-    let chunk = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
-
-    let chunks = chunk.iter().cloned().collect::<Vec<u8>>();
-    serde_json::from_slice(&chunks.as_slice())
+    serde_json::from_slice(&bytes)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to deserialize JSON into a list of attestations: {:?}",
@@ -474,16 +436,16 @@ pub async fn publish_attestations<T: BeaconChainTypes>(
        .map(
            move |attestations: Vec<(Attestation<T::EthSpec>, SubnetId)>| {
                attestations
-                    .into_par_iter()
+                    .into_iter()
                    .enumerate()
                    .map(|(i, (attestation, subnet_id))| {
                        process_unaggregated_attestation(
-                            &beacon_chain,
-                            network_chan.clone(),
+                            &ctx.beacon_chain,
+                            ctx.network_chan.clone(),
                            attestation,
                            subnet_id,
                            i,
-                            &log,
+                            &ctx.log,
                        )
                    })
                    .collect::<Vec<Result<_, _>>>()
@@ -493,7 +455,7 @@ pub async fn publish_attestations<T: BeaconChainTypes>(
        //
        // Note: this will only provide info about the _first_ failure, not all failures.
        .and_then(|processing_results| processing_results.into_iter().try_for_each(|result| result))
-        .and_then(|_| response_builder?.body_no_ssz(&()))
+        .map(|_| ())
 }

 /// Processes an unaggregrated attestation that was included in a list of attestations with the
@@ -566,21 +528,13 @@ fn process_unaggregated_attestation<T: BeaconChainTypes>(
 }

 /// HTTP Handler to publish an Attestation, which has been signed by a validator.
-#[allow(clippy::redundant_clone)] // false positives in this function.
-pub async fn publish_aggregate_and_proofs<T: BeaconChainTypes>(
-    req: Request<Body>,
-    beacon_chain: Arc<BeaconChain<T>>,
-    network_chan: NetworkChannel<T::EthSpec>,
-    log: Logger,
-) -> ApiResult {
-    try_future!(check_content_type_for_json(&req));
-    let response_builder = ResponseBuilder::new(&req);
+pub fn publish_aggregate_and_proofs<T: BeaconChainTypes>(
+    req: Request<Vec<u8>>,
+    ctx: Arc<Context<T>>,
+) -> Result<(), ApiError> {
    let body = req.into_body();
-    let chunk = hyper::body::to_bytes(body)
-        .await
-        .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
-    let chunks = chunk.iter().cloned().collect::<Vec<u8>>();
-    serde_json::from_slice(&chunks.as_slice())
+
+    serde_json::from_slice(&body)
        .map_err(|e| {
            ApiError::BadRequest(format!(
                "Unable to deserialize JSON into a list of SignedAggregateAndProof: {:?}",
@@ -591,15 +545,15 @@ pub async fn publish_aggregate_and_proofs<T: BeaconChainTypes>(
        .map(
            move |signed_aggregates: Vec<SignedAggregateAndProof<T::EthSpec>>| {
                signed_aggregates
-                    .into_par_iter()
+                    .into_iter()
                    .enumerate()
                    .map(|(i, signed_aggregate)| {
                        process_aggregated_attestation(
-                            &beacon_chain,
-                            network_chan.clone(),
+                            &ctx.beacon_chain,
+                            ctx.network_chan.clone(),
                            signed_aggregate,
                            i,
-                            &log,
+                            &ctx.log,
                        )
                    })
                    .collect::<Vec<Result<_, _>>>()
@@ -609,7 +563,6 @@ pub async fn publish_aggregate_and_proofs<T: BeaconChainTypes>(
        //
        // Note: this will only provide info about the _first_ failure, not all failures.
        .and_then(|processing_results| processing_results.into_iter().try_for_each(|result| result))
-        .and_then(|_| response_builder?.body_no_ssz(&()))
 }

 /// Processes an aggregrated attestation that was included in a list of attestations with the index
--- a/beacon_node/rest_api/tests/test.rs
+++ b/beacon_node/rest_api/tests/test.rs
@@ -804,7 +804,7 @@ fn get_version() {
    let version = env
        .runtime()
        .block_on(remote_node.http.node().get_version())
-        .expect("should fetch eth2 config from http api");
+        .expect("should fetch version from http api");

    assert_eq!(
        lighthouse_version::version_with_platform(),
--- a/beacon_node/src/config.rs
+++ b/beacon_node/src/config.rs
@@ -2,7 +2,7 @@ use beacon_chain::builder::PUBKEY_CACHE_FILENAME;
 use clap::ArgMatches;
 use clap_utils::BAD_TESTNET_DIR_MESSAGE;
 use client::{config::DEFAULT_DATADIR, ClientConfig, ClientGenesis};
-use eth2_libp2p::{multiaddr::Protocol, Enr, Multiaddr};
+use eth2_libp2p::{multiaddr::Protocol, Enr, Multiaddr, NetworkConfig};
 use eth2_testnet_config::Eth2TestnetConfig;
 use slog::{crit, info, Logger};
 use ssz::Encode;
@@ -75,148 +75,13 @@ pub fn get_config<E: EthSpec>(
    /*
     * Networking
     */
-    // If a network dir has been specified, override the `datadir` definition.
-    if let Some(dir) = cli_args.value_of("network-dir") {
-        client_config.network.network_dir = PathBuf::from(dir);
-    } else {
-        client_config.network.network_dir = client_config.data_dir.join(NETWORK_DIR);
-    };
-
-    if let Some(listen_address_str) = cli_args.value_of("listen-address") {
-        let listen_address = listen_address_str
-            .parse()
-            .map_err(|_| format!("Invalid listen address: {:?}", listen_address_str))?;
-        client_config.network.listen_address = listen_address;
-    }
-
-    if let Some(target_peers_str) = cli_args.value_of("target-peers") {
-        client_config.network.target_peers = target_peers_str
-            .parse::<usize>()
-            .map_err(|_| format!("Invalid number of target peers: {}", target_peers_str))?;
-    }
-
-    if let Some(port_str) = cli_args.value_of("port") {
-        let port = port_str
-            .parse::<u16>()
-            .map_err(|_| format!("Invalid port: {}", port_str))?;
-        client_config.network.libp2p_port = port;
-        client_config.network.discovery_port = port;
-    }
-
-    if let Some(port_str) = cli_args.value_of("discovery-port") {
-        let port = port_str
-            .parse::<u16>()
-            .map_err(|_| format!("Invalid port: {}", port_str))?;
-        client_config.network.discovery_port = port;
-    }
-
-    if let Some(boot_enr_str) = cli_args.value_of("boot-nodes") {
-        let mut enrs: Vec<Enr> = vec![];
-        let mut multiaddrs: Vec<Multiaddr> = vec![];
-        for addr in boot_enr_str.split(',') {
-            match addr.parse() {
-                Ok(enr) => enrs.push(enr),
-                Err(_) => {
-                    // parsing as ENR failed, try as Multiaddr
-                    let multi: Multiaddr = addr
-                        .parse()
-                        .map_err(|_| format!("Not valid as ENR nor Multiaddr: {}", addr))?;
-                    if !multi.iter().any(|proto| matches!(proto, Protocol::Udp(_))) {
-                        slog::error!(log, "Missing UDP in Multiaddr {}", multi.to_string());
-                    }
-                    if !multi.iter().any(|proto| matches!(proto, Protocol::P2p(_))) {
-                        slog::error!(log, "Missing P2P in Multiaddr {}", multi.to_string());
-                    }
-                    multiaddrs.push(multi);
-                }
-            }
-        }
-        client_config.network.boot_nodes_enr = enrs;
-        client_config.network.boot_nodes_multiaddr = multiaddrs;
-    }
-
-    if let Some(libp2p_addresses_str) = cli_args.value_of("libp2p-addresses") {
-        client_config.network.libp2p_nodes = libp2p_addresses_str
-            .split(',')
-            .map(|multiaddr| {
-                multiaddr
-                    .parse()
-                    .map_err(|_| format!("Invalid Multiaddr: {}", multiaddr))
-            })
-            .collect::<Result<Vec<Multiaddr>, _>>()?;
-    }
-
-    if let Some(enr_udp_port_str) = cli_args.value_of("enr-udp-port") {
-        client_config.network.enr_udp_port = Some(
-            enr_udp_port_str
-                .parse::<u16>()
-                .map_err(|_| format!("Invalid discovery port: {}", enr_udp_port_str))?,
-        );
-    }
-
-    if let Some(enr_tcp_port_str) = cli_args.value_of("enr-tcp-port") {
-        client_config.network.enr_tcp_port = Some(
-            enr_tcp_port_str
-                .parse::<u16>()
-                .map_err(|_| format!("Invalid ENR TCP port: {}", enr_tcp_port_str))?,
-        );
-    }
-
-    if cli_args.is_present("enr-match") {
-        // set the enr address to localhost if the address is 0.0.0.0
-        if client_config.network.listen_address
-            == "0.0.0.0".parse::<IpAddr>().expect("valid ip addr")
-        {
-            client_config.network.enr_address =
-                Some("127.0.0.1".parse::<IpAddr>().expect("valid ip addr"));
-        } else {
-            client_config.network.enr_address = Some(client_config.network.listen_address);
-        }
-        client_config.network.enr_udp_port = Some(client_config.network.discovery_port);
-    }
-
-    if let Some(enr_address) = cli_args.value_of("enr-address") {
-        let resolved_addr = match enr_address.parse::<IpAddr>() {
-            Ok(addr) => addr, // // Input is an IpAddr
-            Err(_) => {
-                let mut addr = enr_address.to_string();
-                // Appending enr-port to the dns hostname to appease `to_socket_addrs()` parsing.
-                // Since enr-update is disabled with a dns address, not setting the enr-udp-port
-                // will make the node undiscoverable.
-                if let Some(enr_udp_port) = client_config.network.enr_udp_port {
-                    addr.push_str(&format!(":{}", enr_udp_port.to_string()));
-                } else {
-                    return Err(
-                        "enr-udp-port must be set for node to be discoverable with dns address"
-                            .into(),
-                    );
-                }
-                // `to_socket_addr()` does the dns resolution
-                // Note: `to_socket_addrs()` is a blocking call
-                let resolved_addr = if let Ok(mut resolved_addrs) = addr.to_socket_addrs() {
-                    // Pick the first ip from the list of resolved addresses
-                    resolved_addrs
-                        .next()
-                        .map(|a| a.ip())
-                        .ok_or_else(|| "Resolved dns addr contains no entries".to_string())?
-                } else {
-                    return Err(format!("Failed to parse enr-address: {}", enr_address));
-                };
-                client_config.network.discv5_config.enr_update = false;
-                resolved_addr
-            }
-        };
-        client_config.network.enr_address = Some(resolved_addr);
-    }
-
-    if cli_args.is_present("disable_enr_auto_update") {
-        client_config.network.discv5_config.enr_update = false;
-    }
-
-    if cli_args.is_present("disable-discovery") {
-        client_config.network.disable_discovery = true;
-        slog::warn!(log, "Discovery is disabled. New peers will not be found");
-    }
+    set_network_config(
+        &mut client_config.network,
+        cli_args,
+        &client_config.data_dir,
+        &log,
+        false,
+    )?;

    /*
     * Http server
@@ -399,6 +264,163 @@ pub fn get_config<E: EthSpec>(
    Ok(client_config)
 }

+/// Sets the network config from the command line arguments
+pub fn set_network_config(
+    config: &mut NetworkConfig,
+    cli_args: &ArgMatches,
+    data_dir: &PathBuf,
+    log: &Logger,
+    use_listening_port_as_enr_port_by_default: bool,
+) -> Result<(), String> {
+    // If a network dir has been specified, override the `datadir` definition.
+    if let Some(dir) = cli_args.value_of("network-dir") {
+        config.network_dir = PathBuf::from(dir);
+    } else {
+        config.network_dir = data_dir.join(NETWORK_DIR);
+    };
+
+    if let Some(listen_address_str) = cli_args.value_of("listen-address") {
+        let listen_address = listen_address_str
+            .parse()
+            .map_err(|_| format!("Invalid listen address: {:?}", listen_address_str))?;
+        config.listen_address = listen_address;
+    }
+
+    if let Some(target_peers_str) = cli_args.value_of("target-peers") {
+        config.target_peers = target_peers_str
+            .parse::<usize>()
+            .map_err(|_| format!("Invalid number of target peers: {}", target_peers_str))?;
+    }
+
+    if let Some(port_str) = cli_args.value_of("port") {
+        let port = port_str
+            .parse::<u16>()
+            .map_err(|_| format!("Invalid port: {}", port_str))?;
+        config.libp2p_port = port;
+        config.discovery_port = port;
+    }
+
+    if let Some(port_str) = cli_args.value_of("discovery-port") {
+        let port = port_str
+            .parse::<u16>()
+            .map_err(|_| format!("Invalid port: {}", port_str))?;
+        config.discovery_port = port;
+    }
+
+    if let Some(boot_enr_str) = cli_args.value_of("boot-nodes") {
+        let mut enrs: Vec<Enr> = vec![];
+        let mut multiaddrs: Vec<Multiaddr> = vec![];
+        for addr in boot_enr_str.split(',') {
+            match addr.parse() {
+                Ok(enr) => enrs.push(enr),
+                Err(_) => {
+                    // parsing as ENR failed, try as Multiaddr
+                    let multi: Multiaddr = addr
+                        .parse()
+                        .map_err(|_| format!("Not valid as ENR nor Multiaddr: {}", addr))?;
+                    if !multi.iter().any(|proto| matches!(proto, Protocol::Udp(_))) {
+                        slog::error!(log, "Missing UDP in Multiaddr {}", multi.to_string());
+                    }
+                    if !multi.iter().any(|proto| matches!(proto, Protocol::P2p(_))) {
+                        slog::error!(log, "Missing P2P in Multiaddr {}", multi.to_string());
+                    }
+                    multiaddrs.push(multi);
+                }
+            }
+        }
+        config.boot_nodes_enr = enrs;
+        config.boot_nodes_multiaddr = multiaddrs;
+    }
+
+    if let Some(libp2p_addresses_str) = cli_args.value_of("libp2p-addresses") {
+        config.libp2p_nodes = libp2p_addresses_str
+            .split(',')
+            .map(|multiaddr| {
+                multiaddr
+                    .parse()
+                    .map_err(|_| format!("Invalid Multiaddr: {}", multiaddr))
+            })
+            .collect::<Result<Vec<Multiaddr>, _>>()?;
+    }
+
+    if let Some(enr_udp_port_str) = cli_args.value_of("enr-udp-port") {
+        config.enr_udp_port = Some(
+            enr_udp_port_str
+                .parse::<u16>()
+                .map_err(|_| format!("Invalid discovery port: {}", enr_udp_port_str))?,
+        );
+    }
+
+    if let Some(enr_tcp_port_str) = cli_args.value_of("enr-tcp-port") {
+        config.enr_tcp_port = Some(
+            enr_tcp_port_str
+                .parse::<u16>()
+                .map_err(|_| format!("Invalid ENR TCP port: {}", enr_tcp_port_str))?,
+        );
+    }
+
+    if cli_args.is_present("enr-match") {
+        // set the enr address to localhost if the address is 0.0.0.0
+        if config.listen_address == "0.0.0.0".parse::<IpAddr>().expect("valid ip addr") {
+            config.enr_address = Some("127.0.0.1".parse::<IpAddr>().expect("valid ip addr"));
+        } else {
+            config.enr_address = Some(config.listen_address);
+        }
+        config.enr_udp_port = Some(config.discovery_port);
+    }
+
+    if let Some(enr_address) = cli_args.value_of("enr-address") {
+        let resolved_addr = match enr_address.parse::<IpAddr>() {
+            Ok(addr) => addr, // // Input is an IpAddr
+            Err(_) => {
+                let mut addr = enr_address.to_string();
+                // Appending enr-port to the dns hostname to appease `to_socket_addrs()` parsing.
+                // Since enr-update is disabled with a dns address, not setting the enr-udp-port
+                // will make the node undiscoverable.
+                if let Some(enr_udp_port) = config.enr_udp_port.or_else(|| {
+                    if use_listening_port_as_enr_port_by_default {
+                        Some(config.discovery_port)
+                    } else {
+                        None
+                    }
+                }) {
+                    addr.push_str(&format!(":{}", enr_udp_port.to_string()));
+                } else {
+                    return Err(
+                        "enr-udp-port must be set for node to be discoverable with dns address"
+                            .into(),
+                    );
+                }
+                // `to_socket_addr()` does the dns resolution
+                // Note: `to_socket_addrs()` is a blocking call
+                let resolved_addr = if let Ok(mut resolved_addrs) = addr.to_socket_addrs() {
+                    // Pick the first ip from the list of resolved addresses
+                    resolved_addrs
+                        .next()
+                        .map(|a| a.ip())
+                        .ok_or_else(|| "Resolved dns addr contains no entries".to_string())?
+                } else {
+                    return Err(format!("Failed to parse enr-address: {}", enr_address));
+                };
+                config.discv5_config.enr_update = false;
+                resolved_addr
+            }
+        };
+        config.enr_address = Some(resolved_addr);
+    }
+
+    if cli_args.is_present("disable_enr_auto_update") {
+        config.discv5_config.enr_update = false;
+    }
+
+    if cli_args.is_present("disable-discovery") {
+        config.disable_discovery = true;
+        slog::warn!(log, "Discovery is disabled. New peers will not be found");
+    }
+
+    Ok(())
+}
+
 /// Gets the datadir which should be used.
 pub fn get_data_dir(cli_args: &ArgMatches) -> PathBuf {
    // Read the `--datadir` flag.
--- a/beacon_node/src/lib.rs
+++ b/beacon_node/src/lib.rs
@@ -7,7 +7,7 @@ mod config;
 pub use beacon_chain;
 pub use cli::cli_app;
 pub use client::{Client, ClientBuilder, ClientConfig, ClientGenesis};
-pub use config::{get_data_dir, get_eth2_testnet_config};
+pub use config::{get_data_dir, get_eth2_testnet_config, set_network_config};
 pub use eth2_config::Eth2Config;

 use beacon_chain::events::TeeEventHandler;
--- a/beacon_node/store/src/hot_cold_store.rs
+++ b/beacon_node/store/src/hot_cold_store.rs
@@ -14,7 +14,7 @@ use crate::{
 };
 use lru::LruCache;
 use parking_lot::{Mutex, RwLock};
-use slog::{debug, error, trace, warn, Logger};
+use slog::{debug, error, info, trace, warn, Logger};
 use ssz::{Decode, Encode};
 use ssz_derive::{Decode, Encode};
 use state_processing::{
@@ -147,6 +147,12 @@ impl<E: EthSpec> HotColdDB<E, LevelDB<E>, LevelDB<E>> {
        // Load the previous split slot from the database (if any). This ensures we can
        // stop and restart correctly.
        if let Some(split) = db.load_split()? {
+            info!(
+                db.log,
+                "Hot-Cold DB initialized";
+                "split_slot" => split.slot,
+                "split_state" => format!("{:?}", split.state_root)
+            );
            *db.split.write() = split;
        }
        Ok(db)
@@ -819,7 +825,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
 }

 /// Advance the split point of the store, moving new finalized states to the freezer.
-pub fn process_finalization<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
+pub fn migrate_database<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>>(
    store: Arc<HotColdDB<E, Hot, Cold>>,
    frozen_head_root: Hash256,
    frozen_head: &BeaconState<E>,
--- a/beacon_node/store/src/lib.rs
+++ b/beacon_node/store/src/lib.rs
@@ -27,7 +27,7 @@ pub mod iter;
 use std::borrow::Cow;

 pub use self::config::StoreConfig;
-pub use self::hot_cold_store::{HotColdDB, HotStateSummary, Split};
+pub use self::hot_cold_store::{BlockReplay, HotColdDB, HotStateSummary, Split};
 pub use self::leveldb_store::LevelDB;
 pub use self::memory_store::MemoryStore;
 pub use self::partial_beacon_state::PartialBeaconState;
--- a/book/src/key-management.md
+++ b/book/src/key-management.md
@@ -44,7 +44,7 @@ In step (1), we created a wallet in `~/.lighthouse/wallets` with the name
 `wally`. We encrypted this using a pre-defined password in the
 `wally.pass` file. Then, in step (2), we created one new validator in the
 `~/.lighthouse/validators` directory using `wally` (unlocking it with
-`mywallet.pass`) and storing the passwords to the validators voting key in
+`wally.pass`) and storing the passwords to the validators voting key in
 `~/.lighthouse/secrets`.

 Thanks to the hierarchical key derivation scheme, we can delete all of the
--- a/boot_node/Cargo.toml
+++ b/boot_node/Cargo.toml
@@ -1,10 +1,11 @@
 [package]
 name = "boot_node"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = "2018"

 [dependencies]
+beacon_node = { path = "../beacon_node" }
 clap = "2.33.0"
 eth2_libp2p = { path = "../beacon_node/eth2_libp2p" } 
 slog = "2.5.2"
--- a/boot_node/src/cli.rs
+++ b/boot_node/src/cli.rs
@@ -12,7 +12,7 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
        surface compared to a full beacon node.")
        .settings(&[clap::AppSettings::ColoredHelp])
        .arg(
-            Arg::with_name("boot-node-enr-address")
+            Arg::with_name("enr-address")
                .value_name("IP-ADDRESS")
                .help("The external IP address/ DNS address to broadcast to other peers on how to reach this node. \
                If a DNS address is provided, the enr-address is set to the IP address it resolves to and \
@@ -44,7 +44,7 @@ pub fn cli_app<'a, 'b>() -> App<'a, 'b> {
                .takes_value(true),
        )
        .arg(
-            Arg::with_name("enr-port")
+            Arg::with_name("enr-udp-port")
                .long("enr-port")
                .value_name("PORT")
                .help("The UDP port of the boot node's ENR. This is the port that external peers will dial to reach this boot node. Set this only if the external port differs from the listening port.")
--- a/boot_node/src/config.rs
+++ b/boot_node/src/config.rs
@@ -1,7 +1,12 @@
+use beacon_node::{get_data_dir, set_network_config};
 use clap::ArgMatches;
 use discv5::{enr::CombinedKey, Enr};
+use eth2_libp2p::{
+    discovery::{create_enr_builder_from_config, use_or_load_enr},
+    load_private_key, CombinedKeyExt, NetworkConfig,
+};
 use std::convert::TryFrom;
-use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
+use std::net::SocketAddr;

 /// A set of configuration parameters for the bootnode, established from CLI arguments.
 pub struct BootNodeConfig {
@@ -17,17 +22,22 @@ impl TryFrom<&ArgMatches<'_>> for BootNodeConfig {
    type Error = String;

    fn try_from(matches: &ArgMatches<'_>) -> Result<Self, Self::Error> {
-        let listen_address = matches
-            .value_of("listen-address")
-            .expect("required parameter")
-            .parse::<IpAddr>()
-            .map_err(|_| "Invalid listening address".to_string())?;
+        let data_dir = get_data_dir(matches);

-        let listen_port = matches
-            .value_of("port")
-            .expect("required parameter")
-            .parse::<u16>()
-            .map_err(|_| "Invalid listening port".to_string())?;
+        let mut network_config = NetworkConfig::default();
+
+        let logger = slog_scope::logger();
+
+        set_network_config(&mut network_config, matches, &data_dir, &logger, true)?;
+
+        let private_key = load_private_key(&network_config, &logger);
+        let local_key = CombinedKey::from_libp2p(&private_key)?;
+
+        let mut local_enr = create_enr_builder_from_config(&network_config)
+            .build(&local_key)
+            .map_err(|e| format!("Failed to build ENR: {:?}", e))?;
+
+        use_or_load_enr(&local_key, &mut local_enr, &network_config, &logger)?;

        let boot_nodes = {
            if let Some(boot_nodes) = matches.value_of("boot-nodes") {
@@ -40,34 +50,11 @@ impl TryFrom<&ArgMatches<'_>> for BootNodeConfig {
            }
        };

-        let enr_port = {
-            if let Some(port) = matches.value_of("boot-node-enr-port") {
-                port.parse::<u16>()
-                    .map_err(|_| "Invalid ENR port".to_string())?
-            } else {
-                listen_port
-            }
-        };
-
-        let enr_address = {
-            let address_string = matches
-                .value_of("boot-node-enr-address")
-                .expect("required parameter");
-            resolve_address(address_string.into(), enr_port)?
-        };
-
        let auto_update = matches.is_present("enable-enr_auto_update");

        // the address to listen on
-        let listen_socket = SocketAddr::new(listen_address, enr_port);
-
-        // Generate a new key and build a new ENR
-        let local_key = CombinedKey::generate_secp256k1();
-        let local_enr = discv5::enr::EnrBuilder::new("v4")
-            .ip(enr_address)
-            .udp(enr_port)
-            .build(&local_key)
-            .map_err(|e| format!("Failed to build ENR: {:?}", e))?;
+        let listen_socket =
+            SocketAddr::new(network_config.listen_address, network_config.discovery_port);

        Ok(BootNodeConfig {
            listen_socket,
@@ -78,25 +65,3 @@ impl TryFrom<&ArgMatches<'_>> for BootNodeConfig {
        })
    }
 }
-
-/// Resolves an IP/DNS string to an IpAddr.
-fn resolve_address(address_string: String, port: u16) -> Result<IpAddr, String> {
-    match address_string.parse::<IpAddr>() {
-        Ok(addr) => Ok(addr), // valid IpAddr
-        Err(_) => {
-            let mut addr = address_string.clone();
-            // Appending enr-port to the dns hostname to appease `to_socket_addrs()` parsing.
-            addr.push_str(&format!(":{}", port.to_string()));
-            // `to_socket_addr()` does the dns resolution
-            // Note: `to_socket_addrs()` is a blocking call
-            addr.to_socket_addrs()
-                .map(|mut resolved_addrs|
-                    // Pick the first ip from the list of resolved addresses
-                    resolved_addrs
-                        .next()
-                        .map(|a| a.ip())
-                        .ok_or_else(|| "Resolved dns addr contains no entries".to_string()))
-                .map_err(|_| format!("Failed to parse enr-address: {}", address_string))?
-        }
-    }
-}
--- a/common/lighthouse_version/src/lib.rs
+++ b/common/lighthouse_version/src/lib.rs
@@ -10,7 +10,7 @@ use target_info::Target;
 /// `Lighthouse/v0.2.0-1419501f2+`
 pub const VERSION: &str = git_version!(
    args = ["--always", "--dirty=+"],
-    prefix = "Lighthouse/v0.2.6-",
+    prefix = "Lighthouse/v0.2.8-",
    fallback = "unknown"
 );

--- a/common/rest_types/Cargo.toml
+++ b/common/rest_types/Cargo.toml
@@ -14,6 +14,13 @@ state_processing = { path = "../../consensus/state_processing" }
 bls = { path = "../../crypto/bls" }
 serde = { version = "1.0.110", features = ["derive"] }
 rayon = "1.3.0"
+hyper = "0.13.5"
+tokio = { version = "0.2.21", features = ["sync"] }
+environment = { path = "../../lighthouse/environment" }
+store = { path = "../../beacon_node/store" }
+beacon_chain = { path = "../../beacon_node/beacon_chain" }
+serde_json = "1.0.52"
+serde_yaml = "0.8.11"

 [target.'cfg(target_os = "linux")'.dependencies]
 psutil = "3.1.0"
--- a/common/rest_types/src/api_error.rs
+++ b/common/rest_types/src/api_error.rs
--- a/common/rest_types/src/handler.rs
+++ b/common/rest_types/src/handler.rs
@@ -0,0 +1,247 @@
+use crate::{ApiError, ApiResult};
+use environment::TaskExecutor;
+use hyper::header;
+use hyper::{Body, Request, Response, StatusCode};
+use serde::Deserialize;
+use serde::Serialize;
+use ssz::Encode;
+
+/// Defines the encoding for the API.
+#[derive(Clone, Serialize, Deserialize, Copy)]
+pub enum ApiEncodingFormat {
+    JSON,
+    YAML,
+    SSZ,
+}
+
+impl ApiEncodingFormat {
+    pub fn get_content_type(&self) -> &str {
+        match self {
+            ApiEncodingFormat::JSON => "application/json",
+            ApiEncodingFormat::YAML => "application/yaml",
+            ApiEncodingFormat::SSZ => "application/ssz",
+        }
+    }
+}
+
+impl From<&str> for ApiEncodingFormat {
+    fn from(f: &str) -> ApiEncodingFormat {
+        match f {
+            "application/yaml" => ApiEncodingFormat::YAML,
+            "application/ssz" => ApiEncodingFormat::SSZ,
+            _ => ApiEncodingFormat::JSON,
+        }
+    }
+}
+
+/// Provides a HTTP request handler with Lighthouse-specific functionality.
+pub struct Handler<T> {
+    executor: TaskExecutor,
+    req: Request<()>,
+    body: Body,
+    ctx: T,
+    encoding: ApiEncodingFormat,
+    allow_body: bool,
+}
+
+impl<T: Clone + Send + Sync + 'static> Handler<T> {
+    /// Start handling a new request.
+    pub fn new(req: Request<Body>, ctx: T, executor: TaskExecutor) -> Result<Self, ApiError> {
+        let (req_parts, body) = req.into_parts();
+        let req = Request::from_parts(req_parts, ());
+
+        let accept_header: String = req
+            .headers()
+            .get(header::ACCEPT)
+            .map_or(Ok(""), |h| h.to_str())
+            .map_err(|e| {
+                ApiError::BadRequest(format!(
+                    "The Accept header contains invalid characters: {:?}",
+                    e
+                ))
+            })
+            .map(String::from)?;
+
+        Ok(Self {
+            executor,
+            req,
+            body,
+            ctx,
+            allow_body: false,
+            encoding: ApiEncodingFormat::from(accept_header.as_str()),
+        })
+    }
+
+    /// The default behaviour is to return an error if any body is supplied in the request. Calling
+    /// this function disables that error.
+    pub fn allow_body(mut self) -> Self {
+        self.allow_body = true;
+        self
+    }
+
+    /// Return a simple static value.
+    ///
+    /// Does not use the blocking executor.
+    pub async fn static_value<V>(self, value: V) -> Result<HandledRequest<V>, ApiError> {
+        // Always check and disallow a body for a static value.
+        let _ = Self::get_body(self.body, false).await?;
+
+        Ok(HandledRequest {
+            value,
+            encoding: self.encoding,
+        })
+    }
+
+    /// Calls `func` in-line, on the core executor.
+    ///
+    /// This should only be used for very fast tasks.
+    pub async fn in_core_task<F, V>(self, func: F) -> Result<HandledRequest<V>, ApiError>
+    where
+        V: Send + Sync + 'static,
+        F: Fn(Request<Vec<u8>>, T) -> Result<V, ApiError> + Send + Sync + 'static,
+    {
+        let body = Self::get_body(self.body, self.allow_body).await?;
+        let (req_parts, _) = self.req.into_parts();
+        let req = Request::from_parts(req_parts, body);
+
+        let value = func(req, self.ctx)?;
+
+        Ok(HandledRequest {
+            value,
+            encoding: self.encoding,
+        })
+    }
+
+    /// Spawns `func` on the blocking executor.
+    ///
+    /// This method is suitable for handling long-running or intensive tasks.
+    pub async fn in_blocking_task<F, V>(self, func: F) -> Result<HandledRequest<V>, ApiError>
+    where
+        V: Send + Sync + 'static,
+        F: Fn(Request<Vec<u8>>, T) -> Result<V, ApiError> + Send + Sync + 'static,
+    {
+        let ctx = self.ctx;
+        let body = Self::get_body(self.body, self.allow_body).await?;
+        let (req_parts, _) = self.req.into_parts();
+        let req = Request::from_parts(req_parts, body);
+
+        let value = self
+            .executor
+            .clone()
+            .handle
+            .spawn_blocking(move || func(req, ctx))
+            .await
+            .map_err(|e| {
+                ApiError::ServerError(format!(
+                    "Failed to get blocking join handle: {}",
+                    e.to_string()
+                ))
+            })??;
+
+        Ok(HandledRequest {
+            value,
+            encoding: self.encoding,
+        })
+    }
+
+    /// Call `func`, then return a response that is suitable for an SSE stream.
+    pub async fn sse_stream<F>(self, func: F) -> ApiResult
+    where
+        F: Fn(Request<()>, T) -> Result<Body, ApiError>,
+    {
+        let body = func(self.req, self.ctx)?;
+
+        Response::builder()
+            .status(200)
+            .header("Content-Type", "text/event-stream")
+            .header("Connection", "Keep-Alive")
+            .header("Cache-Control", "no-cache")
+            .header("Access-Control-Allow-Origin", "*")
+            .body(body)
+            .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))
+    }
+
+    /// Downloads the bytes for `body`.
+    async fn get_body(body: Body, allow_body: bool) -> Result<Vec<u8>, ApiError> {
+        let bytes = hyper::body::to_bytes(body)
+            .await
+            .map_err(|e| ApiError::ServerError(format!("Unable to get request body: {:?}", e)))?;
+
+        if !allow_body && !bytes[..].is_empty() {
+            Err(ApiError::BadRequest(
+                "The request body must be empty".to_string(),
+            ))
+        } else {
+            Ok(bytes.into_iter().collect())
+        }
+    }
+}
+
+/// A request that has been "handled" and now a result (`value`) needs to be serialize and
+/// returned.
+pub struct HandledRequest<V> {
+    encoding: ApiEncodingFormat,
+    value: V,
+}
+
+impl HandledRequest<String> {
+    /// Simple encode a string as utf-8.
+    pub fn text_encoding(self) -> ApiResult {
+        Response::builder()
+            .status(StatusCode::OK)
+            .header("content-type", "text/plain; charset=utf-8")
+            .body(Body::from(self.value))
+            .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))
+    }
+}
+
+impl<V: Serialize + Encode> HandledRequest<V> {
+    /// Suitable for all items which implement `serde` and `ssz`.
+    pub fn all_encodings(self) -> ApiResult {
+        match self.encoding {
+            ApiEncodingFormat::SSZ => Response::builder()
+                .status(StatusCode::OK)
+                .header("content-type", "application/ssz")
+                .body(Body::from(self.value.as_ssz_bytes()))
+                .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e))),
+            _ => self.serde_encodings(),
+        }
+    }
+}
+
+impl<V: Serialize> HandledRequest<V> {
+    /// Suitable for items which only implement `serde`.
+    pub fn serde_encodings(self) -> ApiResult {
+        let (body, content_type) = match self.encoding {
+            ApiEncodingFormat::JSON => (
+                Body::from(serde_json::to_string(&self.value).map_err(|e| {
+                    ApiError::ServerError(format!(
+                        "Unable to serialize response body as JSON: {:?}",
+                        e
+                    ))
+                })?),
+                "application/json",
+            ),
+            ApiEncodingFormat::SSZ => {
+                return Err(ApiError::UnsupportedType(
+                    "Response cannot be encoded as SSZ.".into(),
+                ));
+            }
+            ApiEncodingFormat::YAML => (
+                Body::from(serde_yaml::to_string(&self.value).map_err(|e| {
+                    ApiError::ServerError(format!(
+                        "Unable to serialize response body as YAML: {:?}",
+                        e
+                    ))
+                })?),
+                "application/yaml",
+            ),
+        };
+
+        Response::builder()
+            .status(StatusCode::OK)
+            .header("content-type", content_type)
+            .body(body)
+            .map_err(|e| ApiError::ServerError(format!("Failed to build response: {:?}", e)))
+    }
+}
--- a/common/rest_types/src/lib.rs
+++ b/common/rest_types/src/lib.rs
@@ -2,20 +2,21 @@
 //!
 //! This is primarily used by the validator client and the beacon node rest API.

+mod api_error;
 mod beacon;
 mod consensus;
+mod handler;
 mod node;
 mod validator;

+pub use api_error::{ApiError, ApiResult};
 pub use beacon::{
    BlockResponse, CanonicalHeadResponse, Committee, HeadBeaconBlock, StateResponse,
    ValidatorRequest, ValidatorResponse,
 };
-
+pub use consensus::{IndividualVote, IndividualVotesRequest, IndividualVotesResponse};
+pub use handler::{ApiEncodingFormat, Handler};
+pub use node::{Health, SyncingResponse, SyncingStatus};
 pub use validator::{
    ValidatorDutiesRequest, ValidatorDuty, ValidatorDutyBytes, ValidatorSubscription,
 };
-
-pub use consensus::{IndividualVote, IndividualVotesRequest, IndividualVotesResponse};
-
-pub use node::{Health, SyncingResponse, SyncingStatus};
--- a/consensus/fork_choice/tests/tests.rs
+++ b/consensus/fork_choice/tests/tests.rs
@@ -1,8 +1,10 @@
 #![cfg(not(debug_assertions))]

 use beacon_chain::{
-    test_utils::{AttestationStrategy, BeaconChainHarness, BlockStrategy, HarnessType},
-    BeaconChain, BeaconChainError, BeaconForkChoiceStore, ForkChoiceError,
+    test_utils::{
+        AttestationStrategy, BeaconChainHarness, BlockStrategy, NullMigratorEphemeralHarnessType,
+    },
+    BeaconChain, BeaconChainError, BeaconForkChoiceStore, ForkChoiceError, StateSkipConfig,
 };
 use fork_choice::{
    ForkChoiceStore, InvalidAttestation, InvalidBlock, QueuedAttestation,
@@ -18,7 +20,7 @@ use types::{BeaconBlock, BeaconState, Hash256, SignedBeaconBlock};

 pub type E = MainnetEthSpec;

-pub const VALIDATOR_COUNT: usize = 16;
+pub const VALIDATOR_COUNT: usize = 32;

 /// Defines some delay between when an attestation is created and when it is mutated.
 pub enum MutationDelay {
@@ -30,7 +32,7 @@ pub enum MutationDelay {

 /// A helper struct to make testing fork choice more ergonomic and less repetitive.
 struct ForkChoiceTest {
-    harness: BeaconChainHarness<HarnessType<E>>,
+    harness: BeaconChainHarness<NullMigratorEphemeralHarnessType<E>>,
 }

 impl ForkChoiceTest {
@@ -115,22 +117,31 @@ impl ForkChoiceTest {
    }

    /// Build the chain whilst `predicate` returns `true`.
-    pub fn apply_blocks_while<F>(self, mut predicate: F) -> Self
+    pub fn apply_blocks_while<F>(mut self, mut predicate: F) -> Self
    where
        F: FnMut(&BeaconBlock<E>, &BeaconState<E>) -> bool,
    {
        self.harness.advance_slot();
-        self.harness.extend_chain_while(
-            |block, state| predicate(&block.message, state),
-            BlockStrategy::OnCanonicalHead,
-            AttestationStrategy::AllValidators,
-        );
+        let mut state = self.harness.get_current_state();
+        let validators = self.harness.get_all_validators();
+        loop {
+            let slot = self.harness.get_current_slot();
+            let (block, state_) = self.harness.make_block(state, slot);
+            state = state_;
+            if !predicate(&block.message, &state) {
+                break;
+            }
+            let block_hash = self.harness.process_block(slot, block.clone());
+            self.harness
+                .attest_block(&state, block_hash, &block, &validators);
+            self.harness.advance_slot();
+        }

        self
    }

    /// Apply `count` blocks to the chain (with attestations).
-    pub fn apply_blocks(self, count: usize) -> Self {
+    pub fn apply_blocks(mut self, count: usize) -> Self {
        self.harness.advance_slot();
        self.harness.extend_chain(
            count,
@@ -142,7 +153,7 @@ impl ForkChoiceTest {
    }

    /// Apply `count` blocks to the chain (without attestations).
-    pub fn apply_blocks_without_new_attestations(self, count: usize) -> Self {
+    pub fn apply_blocks_without_new_attestations(mut self, count: usize) -> Self {
        self.harness.advance_slot();
        self.harness.extend_chain(
            count,
@@ -181,13 +192,22 @@ impl ForkChoiceTest {
    /// Applies a block directly to fork choice, bypassing the beacon chain.
    ///
    /// Asserts the block was applied successfully.
-    pub fn apply_block_directly_to_fork_choice<F>(self, mut func: F) -> Self
+    pub fn apply_block_directly_to_fork_choice<F>(mut self, mut func: F) -> Self
    where
        F: FnMut(&mut BeaconBlock<E>, &mut BeaconState<E>),
    {
-        let (mut block, mut state) = self.harness.get_block();
+        let state = self
+            .harness
+            .chain
+            .state_at_slot(
+                self.harness.get_current_slot() - 1,
+                StateSkipConfig::WithStateRoots,
+            )
+            .unwrap();
+        let slot = self.harness.get_current_slot();
+        let (mut block, mut state) = self.harness.make_block(state, slot);
        func(&mut block.message, &mut state);
-        let current_slot = self.harness.chain.slot().unwrap();
+        let current_slot = self.harness.get_current_slot();
        self.harness
            .chain
            .fork_choice
@@ -201,7 +221,7 @@ impl ForkChoiceTest {
    ///
    /// Asserts that an error occurred and allows inspecting it via `comparison_func`.
    pub fn apply_invalid_block_directly_to_fork_choice<F, G>(
-        self,
+        mut self,
        mut mutation_func: F,
        mut comparison_func: G,
    ) -> Self
@@ -209,9 +229,18 @@ impl ForkChoiceTest {
        F: FnMut(&mut BeaconBlock<E>, &mut BeaconState<E>),
        G: FnMut(ForkChoiceError),
    {
-        let (mut block, mut state) = self.harness.get_block();
+        let state = self
+            .harness
+            .chain
+            .state_at_slot(
+                self.harness.get_current_slot() - 1,
+                StateSkipConfig::WithStateRoots,
+            )
+            .unwrap();
+        let slot = self.harness.get_current_slot();
+        let (mut block, mut state) = self.harness.make_block(state, slot);
        mutation_func(&mut block.message, &mut state);
-        let current_slot = self.harness.chain.slot().unwrap();
+        let current_slot = self.harness.get_current_slot();
        let err = self
            .harness
            .chain
@@ -267,20 +296,21 @@ impl ForkChoiceTest {
    ///
    /// Also returns some info about who created it.
    fn apply_attestation_to_chain<F, G>(
-        self,
+        mut self,
        delay: MutationDelay,
        mut mutation_func: F,
        mut comparison_func: G,
    ) -> Self
    where
-        F: FnMut(&mut IndexedAttestation<E>, &BeaconChain<HarnessType<E>>),
+        F: FnMut(&mut IndexedAttestation<E>, &BeaconChain<NullMigratorEphemeralHarnessType<E>>),
        G: FnMut(Result<(), BeaconChainError>),
    {
-        let chain = &self.harness.chain;
-        let head = chain.head().expect("should get head");
-        let current_slot = chain.slot().expect("should get slot");
+        let head = self.harness.chain.head().expect("should get head");
+        let current_slot = self.harness.chain.slot().expect("should get slot");

-        let mut attestation = chain
+        let mut attestation = self
+            .harness
+            .chain
            .produce_unaggregated_attestation(current_slot, 0)
            .expect("should not error while producing attestation");

@@ -298,9 +328,13 @@ impl ForkChoiceTest {
            .get_committee_count_at_slot(current_slot)
            .expect("should not error while getting committee count");

-        let subnet_id =
-            SubnetId::compute_subnet::<E>(current_slot, 0, committee_count, &chain.spec)
-                .expect("should compute subnet id");
+        let subnet_id = SubnetId::compute_subnet::<E>(
+            current_slot,
+            0,
+            committee_count,
+            &self.harness.chain.spec,
+        )
+        .expect("should compute subnet id");

        let validator_sk = generate_deterministic_keypair(validator_index).sk;

@@ -309,12 +343,14 @@ impl ForkChoiceTest {
                &validator_sk,
                validator_committee_index,
                &head.beacon_state.fork,
-                chain.genesis_validators_root,
-                &chain.spec,
+                self.harness.chain.genesis_validators_root,
+                &self.harness.chain.spec,
            )
            .expect("should sign attestation");

-        let mut verified_attestation = chain
+        let mut verified_attestation = self
+            .harness
+            .chain
            .verify_unaggregated_attestation_for_gossip(attestation, subnet_id)
            .expect("precondition: should gossip verify attestation");

@@ -327,9 +363,15 @@ impl ForkChoiceTest {
            );
        }

-        mutation_func(verified_attestation.__indexed_attestation_mut(), chain);
+        mutation_func(
+            verified_attestation.__indexed_attestation_mut(),
+            &self.harness.chain,
+        );

-        let result = chain.apply_attestation_to_fork_choice(&verified_attestation);
+        let result = self
+            .harness
+            .chain
+            .apply_attestation_to_fork_choice(&verified_attestation);

        comparison_func(result);

--- a/consensus/proto_array/src/proto_array.rs
+++ b/consensus/proto_array/src/proto_array.rs
@@ -27,7 +27,7 @@ pub struct ProtoNode {
    best_descendant: Option<usize>,
 }

-#[derive(PartialEq, Debug, Serialize, Deserialize)]
+#[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]
 pub struct ProtoArray {
    /// Do not attempt to prune the tree unless it has at least this many nodes. Small prunes
    /// simply waste time.
--- a/lcli/Cargo.toml
+++ b/lcli/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "lcli"
 description = "Lighthouse CLI (modeled after zcli)"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"

--- a/lighthouse/Cargo.toml
+++ b/lighthouse/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lighthouse"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Sigma Prime <contact@sigmaprime.io>"]
 edition = "2018"

--- a/lighthouse/environment/src/executor.rs
+++ b/lighthouse/environment/src/executor.rs
@@ -8,7 +8,7 @@ use tokio::runtime::Handle;
 #[derive(Clone)]
 pub struct TaskExecutor {
    /// The handle to the runtime on which tasks are spawned
-    pub(crate) handle: Handle,
+    pub handle: Handle,
    /// The receiver exit future which on receiving shuts down the task
    pub(crate) exit: exit_future::Exit,
    /// Sender given to tasks, so that if they encounter a state in which execution cannot
--- a/lighthouse/src/main.rs
+++ b/lighthouse/src/main.rs
@@ -189,13 +189,16 @@ fn run<E: EthSpec>(

    // Parse testnet config from the `testnet` and `testnet-dir` flag in that order
    // else, use the default
-    let mut optional_testnet_config = Eth2TestnetConfig::hard_coded_default()?;
+    let mut optional_testnet_config = None;
    if matches.is_present("testnet") {
        optional_testnet_config = clap_utils::parse_hardcoded_network(matches, "testnet")?;
    };
    if matches.is_present("testnet-dir") {
        optional_testnet_config = clap_utils::parse_testnet_dir(matches, "testnet-dir")?;
    };
+    if optional_testnet_config.is_none() {
+        optional_testnet_config = Eth2TestnetConfig::hard_coded_default()?;
+    }

    let builder = if let Some(log_path) = matches.value_of("logfile") {
        let path = log_path
--- a/scripts/change_version.sh
+++ b/scripts/change_version.sh
@@ -0,0 +1,32 @@
+# Change the version across multiple files, prior to a release. Use `sed` to
+# find/replace the exiting version with the new one.
+#
+# Takes two arguments:
+#
+# 1. Current version (e.g., `0.2.6`)
+# 2. New version (e.g., `0.2.7`)
+#
+# ## Example:
+#
+# `./change_version.sh 0.2.6 0.2.7`
+
+FROM=$1
+TO=$2
+VERSION_CRATE="../common/lighthouse_version/src/lib.rs"
+
+update_cargo_toml () {
+	echo $1
+	sed -i -e "s/version = \"$FROM\"/version = \"$TO\"/g" $1
+}
+
+echo "Changing version from $FROM to $TO"
+
+update_cargo_toml ../account_manager/Cargo.toml
+update_cargo_toml ../beacon_node/Cargo.toml
+update_cargo_toml ../boot_node/Cargo.toml
+update_cargo_toml ../lcli/Cargo.toml
+update_cargo_toml ../lighthouse/Cargo.toml
+update_cargo_toml ../validator_client/Cargo.toml
+
+echo $VERSION_CRATE
+sed -i -e "s/$FROM/$TO/g" $VERSION_CRATE
--- a/validator_client/Cargo.toml
+++ b/validator_client/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "validator_client"
-version = "0.2.6"
+version = "0.2.8"
 authors = ["Paul Hauner <paul@paulhauner.com>", "Age Manning <Age@AgeManning.com>", "Luke Anderson <luke@lukeanderson.com.au>"]
 edition = "2018"
Author	SHA1	Message	Date
Paul Hauner	967700c1ff	Bump version to v0.2.8 (#1572 ) ## Issue Addressed NA ## Proposed Changes - Bump versions - Run `cargo update` ## Additional Info NA	2020-08-27 07:04:12 +00:00
Adam Szkoda	d9f4819fe0	Alternative (to BeaconChainHarness) BeaconChain testing API (#1380 ) The PR: * Adds the ability to generate a crucial test scenario that isn't possible with `BeaconChainHarness` (i.e. two blocks occupying the same slot; previously forks necessitated skipping slots): ![image](https://user-images.githubusercontent.com/165678/88195404-4bce3580-cc40-11ea-8c08-b48d2e1d5959.png) * New testing API: Instead of repeatedly calling add_block(), you generate a sorted `Vec<Slot>` and leave it up to the framework to generate blocks at those slots. * Jumping backwards to an earlier epoch is a hard error, so that tests necessarily generate blocks in a epoch-by-epoch manner. * Configures the test logger so that output is printed on the console in case a test fails. The logger also plays well with `--nocapture`, contrary to the existing testing framework * Rewrites existing fork pruning tests to use the new API * Adds a tests that triggers finalization at a non epoch boundary slot * Renamed `BeaconChainYoke` to `BeaconChainTestingRig` because the former has been too confusing * Fixed multiple tests (e.g. `block_production_different_shuffling_long`, `delete_blocks_and_states`, `shuffling_compatible_simple_fork`) that relied on a weird (and accidental) feature of the old `BeaconChainHarness` that attestations aren't produced for epochs earlier than the current one, thus masking potential bugs in test cases. Co-authored-by: Michael Sproul <michael@sigmaprime.io>	2020-08-26 09:24:55 +00:00
Michael Sproul	30bb7aecfb	Check Cargo.lock freshness on CI (#1565 ) Check that `Cargo.lock` is up-to-date on CI so we're not having to push messy lockfile fix ups after releases.	2020-08-26 00:01:08 +00:00
Michael Sproul	4763f03dcc	Fix bug in database pruning (#1564 ) ## Issue Addressed Closes #1488 ## Proposed Changes * Prevent the pruning algorithm from over-eagerly deleting states at skipped slots when they are shared with the canonical chain. * Add `debug` logging to the pruning algorithm so we have so better chance of debugging future issues from logs. * Modify the handling of the "finalized state" in the beacon chain, so that it's always the state at the first slot of the finalized epoch (previously it was the state at the finalized block). This gives database pruning a clearer and cleaner view of things, and will marginally impact the pruning of the op pool, observed proposers, etc (in ways that are safe as far as I can tell). * Remove duplicated `RevertedFinalizedEpoch` check from `after_finalization` * Delete useless and unused `max_finality_distance` * Add tests that exercise pruning with shared states at skip slots * Delete unnecessary `block_strategy` argument from `add_blocks` and friends in the test harness (will likely conflict with #1380 slightly, sorry @adaszko -- but we can fix that) * Bonus: add a `BeaconChain::with_head` method. I didn't end up needing it, but it turned out quite nice, so I figured we could keep it? ## Additional Info Any users who have experienced pruning errors on Medalla will need to resync after upgrading to a release including this change. This should end unbounded `chain_db` growth! 🎉	2020-08-26 00:01:06 +00:00
Pawan Dhananjay	175471a64b	Fix order of testnet config load (#1558 ) ## Issue Addressed Fixes #1552 ## Proposed Changes Earlier, we were always loading the hardcoded default testnet config which is a mainnet spec. So running lighthouse with `--spec` option anything other than mainnet gave errors because we tried loading a mainnet genesis spec with `minimal`/`interop` flags. This PR fixes the order of loading such that we load the hardcoded default spec only if neither `--testnet` and `--testnet-dir` flags are present.	2020-08-25 06:01:42 +00:00
Paul Hauner	dfd02d6179	Bump to v0.2.7 (#1561 ) ## Issue Addressed NA ## Proposed Changes - Update to v0.2.7 - Add script to make update easy. ## Additional Info NA	2020-08-24 08:25:34 +00:00
Paul Hauner	3569506acd	Remove rayon from rest_api (#1562 ) ## Issue Addressed NA ## Proposed Changes Addresses a deadlock condition described here: https://hackmd.io/ijQlqOdqSGaWmIo6zMVV-A?view ## Additional Info NA	2020-08-24 07:28:54 +00:00
Paul Hauner	c895dc8971	Shift HTTP server heavy-lifting to blocking executor (#1518 ) ## Issue Addressed NA ## Proposed Changes Shift practically all HTTP endpoint handlers to the blocking executor (some very light tasks are left on the core executor). ## Additional Info This PR covers the `rest_api` which will soon be refactored to suit the standard API. As such, I've cut a few corners and left some existing issues open in this patch. What I have done here should leave the API in state that is not necessary exactly the same, but good enough for us to run validators with. Specifically, the number of blocking workers that can be spawned is unbounded and I have not implemented a queue; this will need to be fixed when we implement the standard API.	2020-08-24 03:06:10 +00:00
blacktemplar	2bc9115a94	reuse beacon_node methods for initializing network configs in boot_node (#1520 ) ## Issue Addressed #1378 ## Proposed Changes Boot node reuses code from beacon_node to initialize network config. This also enables using the network directory to store/load the enr and the private key. ## Additional Info Note that before this PR the port cli arguments were off (the argument was named `enr-port` but used as `boot-node-enr-port`). Therefore as port always the cli port argument was used (for both enr and listening). Now the enr-port argument can be used to overwrite the listening port as the public port others should connect to. Last but not least note, that this restructuring reuses `ethlibp2p::NetworkConfig` that has many more options than the ones used in the boot node. For example the network config has an own `discv5_config` field that gets never used in the boot node and instead another `Discv5Config` gets created later in the boot node process. Co-authored-by: Age Manning <Age@AgeManning.com>	2020-08-21 12:00:01 +00:00
Nat	3cfd70d7fd	Docs: Fix reference to incorrect password file. (#1556 ) Leftover "mywallet.pass" -> "wally.pass" Thanks @pecurliarly (from Discord)!	2020-08-21 03:50:37 +00:00
blacktemplar	3f0a113c7f	ban IP addresses if too many banned peers for this IP address (#1543 ) ## Issue Addressed #1283 ## Proposed Changes All peers with the same IP will be considered banned as long as there are more than 5 (constant) peers with this IP that have a score below the ban threshold. As soon as some of those 5 peers get unbanned (through decay) and if there are then less than 5 peers with a score below the threshold the IP will be considered not banned anymore.	2020-08-21 01:41:12 +00:00