Repository: tendermint/rust-abci (language: rust)

Issue:
Bump protobuf to 2.11
It should be without any complications -- it's just put as an issue, because the automated dependabot PRs don't seem to commit the re-generated files (and one would like to verify that)
Bump protobuf to 2.12
\+ regenerate definitions

https://github.com/tendermint/rust-abci/pull/126
https://github.com/tendermint/rust-abci/pull/125



Discussion / hints:

Fix patch:
diff --git a/.circleci/config.yml b/.circleci/config.yml
index d9d6010..191d3db 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -8,34 +8,6 @@ jobs:
       - checkout
       - restore_cache:
           key: project-cache
-      - run:
-          name: Check formatting
-          command: |
-            rustup component add rustfmt-preview
-            rustfmt --version
-            cargo fmt -- --check --color=auto
-      - run:
-          name: Check Linting
-          command: |
-            rustup component add clippy
-            cargo clippy
-      - run:
-          name: Nightly Build
-          command: |
-            rustup toolchain install nightly
-            rustup run nightly rustc --version --verbose
-            rustup run nightly cargo --version --verbose
-            rustup run nightly cargo build
-      - run:
-          name: Stable Build
-          command: |
-            rustup toolchain install stable
-            rustup run stable rustc --version --verbose
-            rustup run stable cargo --version --verbose
-            rustup run stable cargo build
-      - run:
-          name: Test
-          command: rustup run stable cargo test
       - run:
           name: Publish Crate
           command: |
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
new file mode 100644
index 0000000..236435c
--- /dev/null
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,54 @@
+name: Rust
+on: [pull_request]
+jobs:
+  cleanup-runs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: rokroskar/workflow-run-cleanup-action@master
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+    if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master'"
+
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  clippy_check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          components: clippy
+          override: true
+      - uses: actions-rs/clippy-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
+
+  test-stable:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --all-targets
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --all-features --no-fail-fast
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a922aa1..5e956aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # CHANGELOG
 
+_June 30, 2020_
+
+## v0.7.1
+
+### IMPROVEMENTS:
+
+- [\#131](https://github.com/tendermint/rust-abci/pull/131): Tendermint 0.33.4+ ABCI compatibility and upgraded protobuf to 2.15.1
+
 _March 3, 2020_
 
 ## v0.7.0
diff --git a/Cargo.toml b/Cargo.toml
index dd7a49a..d23b2ed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "abci"
-version = "0.7.0"
+version = "0.7.1"
 authors = ["Adrian Brink <adrian@brink-holdings.com>", "Jackson Lewis <st.japa6@gmail.com>", "Dave Bryson", "Tomas Tauber"]
 edition = "2018"
 license = "MIT/Apache-2.0"
@@ -13,13 +13,13 @@ include = ["src/**/*", "Cargo.toml"]
 
 [dependencies]
 bytes = "0.4"
-protobuf = "= 2.10.2"
-byteorder = "1.3.2"
-integer-encoding = "1.0.5"
+protobuf = "= 2.15.1"
+byteorder = "1.3.4"
+integer-encoding = "1.1.5"
 log = "0.4.8"
-env_logger = "0.7.0"
+env_logger = "0.7.1"
 tokio = { version = "0.1", default-features = false, features = ["codec", "io", "tcp", "rt-full"] }
 futures = "0.3"
 
 [build-dependencies]
-protobuf-codegen-pure = "= 2.10.2"
+protobuf-codegen-pure = "= 2.15.1"
diff --git a/Makefile b/Makefile
index 6adea77..6b4859e 100644
--- a/Makefile
+++ b/Makefile
@@ -1,12 +1,12 @@
 # Origin
-version_branch = v0.33.1
+version_branch = v0.33.5
 tendermint = https://raw.githubusercontent.com/tendermint/tendermint/$(version_branch)
 
 # Outputs
 tmkv = protobuf/libs/kv/types.proto
 tmmerkle = protobuf/crypto/merkle/merkle.proto
 tmabci = protobuf/abci/types/types.proto
-third_party = protobuf/third_party/proto/gogoproto/gogo.proto
+third_party = third_party/proto/gogoproto/gogo.proto
 
 # You *only* need to run this to rebuild protobufs from the tendermint source
 update-proto:
@@ -15,4 +15,4 @@ update-proto:
 	curl $(tendermint)/crypto/merkle/merkle.proto > $(tmmerkle)
 	sed 's@package types;@package abci;@' $(tmabci) > protobuf/abci.proto
 	curl $(tendermint)/version/version.go | grep -F -eTMCoreSem -eABCISemVer > version.txt
-	curl $(tendermint)/$(third_party) > $(third_party)
+	curl $(tendermint)/$(third_party) > protobuf/$(third_party)
diff --git a/README.md b/README.md
index 9cab78d..cc5dc92 100644
--- a/README.md
+++ b/README.md
@@ -12,8 +12,8 @@ applications for [Tendermint](https://github.com/tendermint/tendermint/).
 
 ## Supported Version
 
-- Tendermint 0.33.1
-- ABCI 0.16.1
+- Tendermint 0.33.5
+- ABCI 0.16.2
 
 ## Installation
 
@@ -33,7 +33,7 @@ To use this library to build your own ABCI apps in Rust you have to include the
 
 ```toml
 [dependencies]
-abci = "0.7.0"
+abci = "0.7.1"
 ```
 
 ### Development
@@ -65,6 +65,7 @@ For a real life example of an ABCI application you can checkout [Cosmos SDK](htt
 
 | Tendermint | Rust-abci |
 | ---------- | :-------: |
+| 0.33.5     |   0.7.1   |
 | 0.33.1     |   0.7.0   |
 | 0.32.9     |   0.6.5   |
 | 0.31.7     |   0.5.4   |
diff --git a/build.rs b/build.rs
index 16de54a..a36c527 100644
--- a/build.rs
+++ b/build.rs
@@ -1,17 +1,14 @@
 extern crate protobuf_codegen_pure;
 
 fn main() {
-    protobuf_codegen_pure::run(protobuf_codegen_pure::Args {
-        out_dir: "src/messages",
-        input: &[
+    protobuf_codegen_pure::Codegen::new()
+        .out_dir("src/messages")
+        .inputs(&[
             "protobuf/abci.proto",
             "protobuf/libs/kv/types.proto",
             "protobuf/crypto/merkle/merkle.proto",
-        ],
-        includes: &["protobuf"],
-        customize: protobuf_codegen_pure::Customize {
-            ..Default::default()
-        },
-    })
-    .expect("protoc");
+        ])
+        .include("protobuf")
+        .run()
+        .expect("protoc");
 }
diff --git a/protobuf/abci.proto b/protobuf/abci.proto
index 0d47ad9..351329d 100644
--- a/protobuf/abci.proto
+++ b/protobuf/abci.proto
@@ -207,7 +207,8 @@ message ResponseEndBlock {
 
 message ResponseCommit {
   // reserve 1
-  bytes data = 2;
+  bytes data          = 2;
+  int64 retain_height = 3;
 }
 
 //----------------------------------------
diff --git a/protobuf/abci/types/types.proto b/protobuf/abci/types/types.proto
index 0d47ad9..351329d 100644
--- a/protobuf/abci/types/types.proto
+++ b/protobuf/abci/types/types.proto
@@ -207,7 +207,8 @@ message ResponseEndBlock {
 
 message ResponseCommit {
   // reserve 1
-  bytes data = 2;
+  bytes data          = 2;
+  int64 retain_height = 3;
 }
 
 //----------------------------------------
diff --git a/protobuf/libs/kv/types.proto b/protobuf/libs/kv/types.proto
index 7e1375c..1b6a7a5 100644
--- a/protobuf/libs/kv/types.proto
+++ b/protobuf/libs/kv/types.proto
@@ -16,14 +16,7 @@ option (gogoproto.testgen_all)  = true;
 //----------------------------------------
 // Abstract types
 
-// Define these here for compatibility but use tmlibs/kv.Pair.
 message Pair {
   bytes key   = 1;
   bytes value = 2;
 }
-
-// Define these here for compatibility but use tmlibs/kv.KI64Pair.
-message KI64Pair {
-  bytes key   = 1;
-  int64 value = 2;
-}
diff --git a/protobuf/third_party/proto/gogoproto/gogo.proto b/protobuf/third_party/proto/gogoproto/gogo.proto
index 806efa3..27960ec 100644
--- a/protobuf/third_party/proto/gogoproto/gogo.proto
+++ b/protobuf/third_party/proto/gogoproto/gogo.proto
@@ -33,115 +33,115 @@ package gogoproto;
 
 import "google/protobuf/descriptor.proto";
 
-option java_package         = "com.google.protobuf";
+option java_package = "com.google.protobuf";
 option java_outer_classname = "GoGoProtos";
-option go_package           = "github.com/gogo/protobuf/gogoproto";
+option go_package = "github.com/gogo/protobuf/gogoproto";
 
 extend google.protobuf.EnumOptions {
-  optional bool   goproto_enum_prefix   = 62001;
-  optional bool   goproto_enum_stringer = 62021;
-  optional bool   enum_stringer         = 62022;
-  optional string enum_customname       = 62023;
-  optional bool   enumdecl              = 62024;
+	optional bool goproto_enum_prefix = 62001;
+	optional bool goproto_enum_stringer = 62021;
+	optional bool enum_stringer = 62022;
+	optional string enum_customname = 62023;
+	optional bool enumdecl = 62024;
 }
 
 extend google.protobuf.EnumValueOptions {
-  optional string enumvalue_customname = 66001;
+	optional string enumvalue_customname = 66001;
 }
 
 extend google.protobuf.FileOptions {
-  optional bool goproto_getters_all     = 63001;
-  optional bool goproto_enum_prefix_all = 63002;
-  optional bool goproto_stringer_all    = 63003;
-  optional bool verbose_equal_all       = 63004;
-  optional bool face_all                = 63005;
-  optional bool gostring_all            = 63006;
-  optional bool populate_all            = 63007;
-  optional bool stringer_all            = 63008;
-  optional bool onlyone_all             = 63009;
-
-  optional bool equal_all            = 63013;
-  optional bool description_all      = 63014;
-  optional bool testgen_all          = 63015;
-  optional bool benchgen_all         = 63016;
-  optional bool marshaler_all        = 63017;
-  optional bool unmarshaler_all      = 63018;
-  optional bool stable_marshaler_all = 63019;
-
-  optional bool sizer_all = 63020;
-
-  optional bool goproto_enum_stringer_all = 63021;
-  optional bool enum_stringer_all         = 63022;
-
-  optional bool unsafe_marshaler_all   = 63023;
-  optional bool unsafe_unmarshaler_all = 63024;
-
-  optional bool goproto_extensions_map_all = 63025;
-  optional bool goproto_unrecognized_all   = 63026;
-  optional bool gogoproto_import           = 63027;
-  optional bool protosizer_all             = 63028;
-  optional bool compare_all                = 63029;
-  optional bool typedecl_all               = 63030;
-  optional bool enumdecl_all               = 63031;
-
-  optional bool goproto_registration = 63032;
-  optional bool messagename_all      = 63033;
-
-  optional bool goproto_sizecache_all = 63034;
-  optional bool goproto_unkeyed_all   = 63035;
+	optional bool goproto_getters_all = 63001;
+	optional bool goproto_enum_prefix_all = 63002;
+	optional bool goproto_stringer_all = 63003;
+	optional bool verbose_equal_all = 63004;
+	optional bool face_all = 63005;
+	optional bool gostring_all = 63006;
+	optional bool populate_all = 63007;
+	optional bool stringer_all = 63008;
+	optional bool onlyone_all = 63009;
+
+	optional bool equal_all = 63013;
+	optional bool description_all = 63014;
+	optional bool testgen_all = 63015;
+	optional bool benchgen_all = 63016;
+	optional bool marshaler_all = 63017;
+	optional bool unmarshaler_all = 63018;
+	optional bool stable_marshaler_all = 63019;
+
+	optional bool sizer_all = 63020;
+
+	optional bool goproto_enum_stringer_all = 63021;
+	optional bool enum_stringer_all = 63022;
+
+	optional bool unsafe_marshaler_all = 63023;
+	optional bool unsafe_unmarshaler_all = 63024;
+
+	optional bool goproto_extensions_map_all = 63025;
+	optional bool goproto_unrecognized_all = 63026;
+	optional bool gogoproto_import = 63027;
+	optional bool protosizer_all = 63028;
+	optional bool compare_all = 63029;
+    optional bool typedecl_all = 63030;
+    optional bool enumdecl_all = 63031;
+
+	optional bool goproto_registration = 63032;
+	optional bool messagename_all = 63033;
+
+	optional bool goproto_sizecache_all = 63034;
+	optional bool goproto_unkeyed_all = 63035;
 }
 
 extend google.protobuf.MessageOptions {
-  optional bool goproto_getters  = 64001;
-  optional bool goproto_stringer = 64003;
-  optional bool verbose_equal    = 64004;
-  optional bool face             = 64005;
-  optional bool gostring         = 64006;
-  optional bool populate         = 64007;
-  optional bool stringer         = 67008;
-  optional bool onlyone          = 64009;
+	optional bool goproto_getters = 64001;
+	optional bool goproto_stringer = 64003;
+	optional bool verbose_equal = 64004;
+	optional bool face = 64005;
+	optional bool gostring = 64006;
+	optional bool populate = 64007;
+	optional bool stringer = 67008;
+	optional bool onlyone = 64009;
 
-  optional bool equal            = 64013;
-  optional bool description      = 64014;
-  optional bool testgen          = 64015;
-  optional bool benchgen         = 64016;
-  optional bool marshaler        = 64017;
-  optional bool unmarshaler      = 64018;
-  optional bool stable_marshaler = 64019;
+	optional bool equal = 64013;
+	optional bool description = 64014;
+	optional bool testgen = 64015;
+	optional bool benchgen = 64016;
+	optional bool marshaler = 64017;
+	optional bool unmarshaler = 64018;
+	optional bool stable_marshaler = 64019;
 
-  optional bool sizer = 64020;
+	optional bool sizer = 64020;
 
-  optional bool unsafe_marshaler   = 64023;
-  optional bool unsafe_unmarshaler = 64024;
+	optional bool unsafe_marshaler = 64023;
+	optional bool unsafe_unmarshaler = 64024;
 
-  optional bool goproto_extensions_map = 64025;
-  optional bool goproto_unrecognized   = 64026;
+	optional bool goproto_extensions_map = 64025;
+	optional bool goproto_unrecognized = 64026;
 
-  optional bool protosizer = 64028;
-  optional bool compare    = 64029;
+	optional bool protosizer = 64028;
+	optional bool compare = 64029;
 
-  optional bool typedecl = 64030;
+	optional bool typedecl = 64030;
 
-  optional bool messagename = 64033;
+	optional bool messagename = 64033;
 
-  optional bool goproto_sizecache = 64034;
-  optional bool goproto_unkeyed   = 64035;
+	optional bool goproto_sizecache = 64034;
+	optional bool goproto_unkeyed = 64035;
 }
 
 extend google.protobuf.FieldOptions {
-  optional bool   nullable   = 65001;
-  optional bool   embed      = 65002;
-  optional string customtype = 65003;
-  optional string customname = 65004;
-  optional string jsontag    = 65005;
-  optional string moretags   = 65006;
-  optional string casttype   = 65007;
-  optional string castkey    = 65008;
-  optional string castvalue  = 65009;
-
-  optional bool stdtime     = 65010;
-  optional bool stdduration = 65011;
-  optional bool wktpointer  = 65012;
-
-  optional string castrepeated = 65013;
-}
+	optional bool nullable = 65001;
+	optional bool embed = 65002;
+	optional string customtype = 65003;
+	optional string customname = 65004;
+	optional string jsontag = 65005;
+	optional string moretags = 65006;
+	optional string casttype = 65007;
+	optional string castkey = 65008;
+	optional string castvalue = 65009;
+
+	optional bool stdtime = 65010;
+	optional bool stdduration = 65011;
+	optional bool wktpointer = 65012;
+
+	optional string castrepeated = 65013;
+} 
\ No newline at end of file
diff --git a/src/messages/abci.rs b/src/messages/abci.rs
index 538ae19..e8aeae8 100644
--- a/src/messages/abci.rs
+++ b/src/messages/abci.rs
@@ -1,11 +1,12 @@
-// This file is generated by rust-protobuf 2.10.2. Do not edit
+// This file is generated by rust-protobuf 2.15.1. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
-#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_attributes)]
+#![rustfmt::skip]
 
 #![allow(box_pointers)]
 #![allow(dead_code)]
@@ -24,7 +25,7 @@ use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
 
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_2;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_15_1;
 
 #[derive(PartialEq,Clone,Default)]
 pub struct Request {
@@ -878,7 +879,7 @@ impl ::protobuf::Message for Request {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -891,10 +892,7 @@ impl ::protobuf::Message for Request {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -953,7 +951,7 @@ impl ::protobuf::Message for Request {
                     Request::has_commit,
                     Request::get_commit,
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Request>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Request>(
                     "Request",
                     fields,
                     file_descriptor_proto()
@@ -963,10 +961,7 @@ impl ::protobuf::Message for Request {
     }
 
     fn default_instance() -> &'static Request {
-        static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Request,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Request> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Request::new)
         }
@@ -997,8 +992,8 @@ impl ::std::fmt::Debug for Request {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Request {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1107,7 +1102,7 @@ impl ::protobuf::Message for RequestEcho {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -1120,10 +1115,7 @@ impl ::protobuf::Message for RequestEcho {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -1132,7 +1124,7 @@ impl ::protobuf::Message for RequestEcho {
                     |m: &RequestEcho| { &m.message },
                     |m: &mut RequestEcho| { &mut m.message },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestEcho>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestEcho>(
                     "RequestEcho",
                     fields,
                     file_descriptor_proto()
@@ -1142,10 +1134,7 @@ impl ::protobuf::Message for RequestEcho {
     }
 
     fn default_instance() -> &'static RequestEcho {
-        static mut instance: ::protobuf::lazy::Lazy<RequestEcho> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestEcho,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestEcho> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestEcho::new)
         }
@@ -1166,8 +1155,8 @@ impl ::std::fmt::Debug for RequestEcho {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestEcho {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1239,7 +1228,7 @@ impl ::protobuf::Message for RequestFlush {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -1252,14 +1241,11 @@ impl ::protobuf::Message for RequestFlush {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let fields = ::std::vec::Vec::new();
-                ::protobuf::reflect::MessageDescriptor::new::<RequestFlush>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestFlush>(
                     "RequestFlush",
                     fields,
                     file_descriptor_proto()
@@ -1269,10 +1255,7 @@ impl ::protobuf::Message for RequestFlush {
     }
 
     fn default_instance() -> &'static RequestFlush {
-        static mut instance: ::protobuf::lazy::Lazy<RequestFlush> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestFlush,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestFlush> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestFlush::new)
         }
@@ -1292,8 +1275,8 @@ impl ::std::fmt::Debug for RequestFlush {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestFlush {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1460,7 +1443,7 @@ impl ::protobuf::Message for RequestInfo {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -1473,10 +1456,7 @@ impl ::protobuf::Message for RequestInfo {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -1495,7 +1475,7 @@ impl ::protobuf::Message for RequestInfo {
                     |m: &RequestInfo| { &m.p2p_version },
                     |m: &mut RequestInfo| { &mut m.p2p_version },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestInfo>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestInfo>(
                     "RequestInfo",
                     fields,
                     file_descriptor_proto()
@@ -1505,10 +1485,7 @@ impl ::protobuf::Message for RequestInfo {
     }
 
     fn default_instance() -> &'static RequestInfo {
-        static mut instance: ::protobuf::lazy::Lazy<RequestInfo> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestInfo,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestInfo> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestInfo::new)
         }
@@ -1531,8 +1508,8 @@ impl ::std::fmt::Debug for RequestInfo {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -1677,7 +1654,7 @@ impl ::protobuf::Message for RequestSetOption {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -1690,10 +1667,7 @@ impl ::protobuf::Message for RequestSetOption {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -1707,7 +1681,7 @@ impl ::protobuf::Message for RequestSetOption {
                     |m: &RequestSetOption| { &m.value },
                     |m: &mut RequestSetOption| { &mut m.value },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestSetOption>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestSetOption>(
                     "RequestSetOption",
                     fields,
                     file_descriptor_proto()
@@ -1717,10 +1691,7 @@ impl ::protobuf::Message for RequestSetOption {
     }
 
     fn default_instance() -> &'static RequestSetOption {
-        static mut instance: ::protobuf::lazy::Lazy<RequestSetOption> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestSetOption,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestSetOption> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestSetOption::new)
         }
@@ -1742,8 +1713,8 @@ impl ::std::fmt::Debug for RequestSetOption {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestSetOption {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2033,7 +2004,7 @@ impl ::protobuf::Message for RequestInitChain {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -2046,10 +2017,7 @@ impl ::protobuf::Message for RequestInitChain {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -2078,7 +2046,7 @@ impl ::protobuf::Message for RequestInitChain {
                     |m: &RequestInitChain| { &m.app_state_bytes },
                     |m: &mut RequestInitChain| { &mut m.app_state_bytes },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestInitChain>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestInitChain>(
                     "RequestInitChain",
                     fields,
                     file_descriptor_proto()
@@ -2088,10 +2056,7 @@ impl ::protobuf::Message for RequestInitChain {
     }
 
     fn default_instance() -> &'static RequestInitChain {
-        static mut instance: ::protobuf::lazy::Lazy<RequestInitChain> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestInitChain,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestInitChain> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestInitChain::new)
         }
@@ -2116,8 +2081,8 @@ impl ::std::fmt::Debug for RequestInitChain {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestInitChain {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2320,7 +2285,7 @@ impl ::protobuf::Message for RequestQuery {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -2333,10 +2298,7 @@ impl ::protobuf::Message for RequestQuery {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -2360,7 +2322,7 @@ impl ::protobuf::Message for RequestQuery {
                     |m: &RequestQuery| { &m.prove },
                     |m: &mut RequestQuery| { &mut m.prove },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestQuery>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestQuery>(
                     "RequestQuery",
                     fields,
                     file_descriptor_proto()
@@ -2370,10 +2332,7 @@ impl ::protobuf::Message for RequestQuery {
     }
 
     fn default_instance() -> &'static RequestQuery {
-        static mut instance: ::protobuf::lazy::Lazy<RequestQuery> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestQuery,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestQuery> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestQuery::new)
         }
@@ -2397,8 +2356,8 @@ impl ::std::fmt::Debug for RequestQuery {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestQuery {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2652,7 +2611,7 @@ impl ::protobuf::Message for RequestBeginBlock {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -2665,10 +2624,7 @@ impl ::protobuf::Message for RequestBeginBlock {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -2692,7 +2648,7 @@ impl ::protobuf::Message for RequestBeginBlock {
                     |m: &RequestBeginBlock| { &m.byzantine_validators },
                     |m: &mut RequestBeginBlock| { &mut m.byzantine_validators },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestBeginBlock>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestBeginBlock>(
                     "RequestBeginBlock",
                     fields,
                     file_descriptor_proto()
@@ -2702,10 +2658,7 @@ impl ::protobuf::Message for RequestBeginBlock {
     }
 
     fn default_instance() -> &'static RequestBeginBlock {
-        static mut instance: ::protobuf::lazy::Lazy<RequestBeginBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestBeginBlock,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestBeginBlock> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestBeginBlock::new)
         }
@@ -2729,8 +2682,8 @@ impl ::std::fmt::Debug for RequestBeginBlock {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestBeginBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -2864,7 +2817,7 @@ impl ::protobuf::Message for RequestCheckTx {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -2877,10 +2830,7 @@ impl ::protobuf::Message for RequestCheckTx {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -2894,7 +2844,7 @@ impl ::protobuf::Message for RequestCheckTx {
                     |m: &RequestCheckTx| { &m.field_type },
                     |m: &mut RequestCheckTx| { &mut m.field_type },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestCheckTx>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestCheckTx>(
                     "RequestCheckTx",
                     fields,
                     file_descriptor_proto()
@@ -2904,10 +2854,7 @@ impl ::protobuf::Message for RequestCheckTx {
     }
 
     fn default_instance() -> &'static RequestCheckTx {
-        static mut instance: ::protobuf::lazy::Lazy<RequestCheckTx> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestCheckTx,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestCheckTx> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestCheckTx::new)
         }
@@ -2929,8 +2876,8 @@ impl ::std::fmt::Debug for RequestCheckTx {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestCheckTx {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3039,7 +2986,7 @@ impl ::protobuf::Message for RequestDeliverTx {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -3052,10 +2999,7 @@ impl ::protobuf::Message for RequestDeliverTx {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -3064,7 +3008,7 @@ impl ::protobuf::Message for RequestDeliverTx {
                     |m: &RequestDeliverTx| { &m.tx },
                     |m: &mut RequestDeliverTx| { &mut m.tx },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestDeliverTx>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestDeliverTx>(
                     "RequestDeliverTx",
                     fields,
                     file_descriptor_proto()
@@ -3074,10 +3018,7 @@ impl ::protobuf::Message for RequestDeliverTx {
     }
 
     fn default_instance() -> &'static RequestDeliverTx {
-        static mut instance: ::protobuf::lazy::Lazy<RequestDeliverTx> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestDeliverTx,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestDeliverTx> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestDeliverTx::new)
         }
@@ -3098,8 +3039,8 @@ impl ::std::fmt::Debug for RequestDeliverTx {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestDeliverTx {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3201,7 +3142,7 @@ impl ::protobuf::Message for RequestEndBlock {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -3214,10 +3155,7 @@ impl ::protobuf::Message for RequestEndBlock {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -3226,7 +3164,7 @@ impl ::protobuf::Message for RequestEndBlock {
                     |m: &RequestEndBlock| { &m.height },
                     |m: &mut RequestEndBlock| { &mut m.height },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<RequestEndBlock>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestEndBlock>(
                     "RequestEndBlock",
                     fields,
                     file_descriptor_proto()
@@ -3236,10 +3174,7 @@ impl ::protobuf::Message for RequestEndBlock {
     }
 
     fn default_instance() -> &'static RequestEndBlock {
-        static mut instance: ::protobuf::lazy::Lazy<RequestEndBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestEndBlock,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestEndBlock> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestEndBlock::new)
         }
@@ -3260,8 +3195,8 @@ impl ::std::fmt::Debug for RequestEndBlock {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestEndBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -3333,7 +3268,7 @@ impl ::protobuf::Message for RequestCommit {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -3346,14 +3281,11 @@ impl ::protobuf::Message for RequestCommit {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let fields = ::std::vec::Vec::new();
-                ::protobuf::reflect::MessageDescriptor::new::<RequestCommit>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<RequestCommit>(
                     "RequestCommit",
                     fields,
                     file_descriptor_proto()
@@ -3363,10 +3295,7 @@ impl ::protobuf::Message for RequestCommit {
     }
 
     fn default_instance() -> &'static RequestCommit {
-        static mut instance: ::protobuf::lazy::Lazy<RequestCommit> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const RequestCommit,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<RequestCommit> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(RequestCommit::new)
         }
@@ -3386,8 +3315,8 @@ impl ::std::fmt::Debug for RequestCommit {
 }
 
 impl ::protobuf::reflect::ProtobufValue for RequestCommit {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4313,7 +4242,7 @@ impl ::protobuf::Message for Response {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -4326,10 +4255,7 @@ impl ::protobuf::Message for Response {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -4393,7 +4319,7 @@ impl ::protobuf::Message for Response {
                     Response::has_commit,
                     Response::get_commit,
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Response>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Response>(
                     "Response",
                     fields,
                     file_descriptor_proto()
@@ -4403,10 +4329,7 @@ impl ::protobuf::Message for Response {
     }
 
     fn default_instance() -> &'static Response {
-        static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Response,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Response> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Response::new)
         }
@@ -4438,8 +4361,8 @@ impl ::std::fmt::Debug for Response {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Response {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4548,7 +4471,7 @@ impl ::protobuf::Message for ResponseException {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -4561,10 +4484,7 @@ impl ::protobuf::Message for ResponseException {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -4573,7 +4493,7 @@ impl ::protobuf::Message for ResponseException {
                     |m: &ResponseException| { &m.error },
                     |m: &mut ResponseException| { &mut m.error },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseException>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseException>(
                     "ResponseException",
                     fields,
                     file_descriptor_proto()
@@ -4583,10 +4503,7 @@ impl ::protobuf::Message for ResponseException {
     }
 
     fn default_instance() -> &'static ResponseException {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseException> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseException,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseException> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseException::new)
         }
@@ -4607,8 +4524,8 @@ impl ::std::fmt::Debug for ResponseException {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseException {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4717,7 +4634,7 @@ impl ::protobuf::Message for ResponseEcho {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -4730,10 +4647,7 @@ impl ::protobuf::Message for ResponseEcho {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -4742,7 +4656,7 @@ impl ::protobuf::Message for ResponseEcho {
                     |m: &ResponseEcho| { &m.message },
                     |m: &mut ResponseEcho| { &mut m.message },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseEcho>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseEcho>(
                     "ResponseEcho",
                     fields,
                     file_descriptor_proto()
@@ -4752,10 +4666,7 @@ impl ::protobuf::Message for ResponseEcho {
     }
 
     fn default_instance() -> &'static ResponseEcho {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseEcho> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseEcho,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseEcho> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseEcho::new)
         }
@@ -4776,8 +4687,8 @@ impl ::std::fmt::Debug for ResponseEcho {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseEcho {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -4849,7 +4760,7 @@ impl ::protobuf::Message for ResponseFlush {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -4862,14 +4773,11 @@ impl ::protobuf::Message for ResponseFlush {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let fields = ::std::vec::Vec::new();
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseFlush>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseFlush>(
                     "ResponseFlush",
                     fields,
                     file_descriptor_proto()
@@ -4879,10 +4787,7 @@ impl ::protobuf::Message for ResponseFlush {
     }
 
     fn default_instance() -> &'static ResponseFlush {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseFlush> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseFlush,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseFlush> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseFlush::new)
         }
@@ -4902,8 +4807,8 @@ impl ::std::fmt::Debug for ResponseFlush {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseFlush {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5142,7 +5047,7 @@ impl ::protobuf::Message for ResponseInfo {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -5155,10 +5060,7 @@ impl ::protobuf::Message for ResponseInfo {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -5187,7 +5089,7 @@ impl ::protobuf::Message for ResponseInfo {
                     |m: &ResponseInfo| { &m.last_block_app_hash },
                     |m: &mut ResponseInfo| { &mut m.last_block_app_hash },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseInfo>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseInfo>(
                     "ResponseInfo",
                     fields,
                     file_descriptor_proto()
@@ -5197,10 +5099,7 @@ impl ::protobuf::Message for ResponseInfo {
     }
 
     fn default_instance() -> &'static ResponseInfo {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseInfo> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseInfo,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseInfo> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseInfo::new)
         }
@@ -5225,8 +5124,8 @@ impl ::std::fmt::Debug for ResponseInfo {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5400,7 +5299,7 @@ impl ::protobuf::Message for ResponseSetOption {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -5413,10 +5312,7 @@ impl ::protobuf::Message for ResponseSetOption {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -5435,7 +5331,7 @@ impl ::protobuf::Message for ResponseSetOption {
                     |m: &ResponseSetOption| { &m.info },
                     |m: &mut ResponseSetOption| { &mut m.info },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseSetOption>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseSetOption>(
                     "ResponseSetOption",
                     fields,
                     file_descriptor_proto()
@@ -5445,10 +5341,7 @@ impl ::protobuf::Message for ResponseSetOption {
     }
 
     fn default_instance() -> &'static ResponseSetOption {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseSetOption> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseSetOption,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseSetOption> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseSetOption::new)
         }
@@ -5471,8 +5364,8 @@ impl ::std::fmt::Debug for ResponseSetOption {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseSetOption {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -5639,7 +5532,7 @@ impl ::protobuf::Message for ResponseInitChain {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -5652,10 +5545,7 @@ impl ::protobuf::Message for ResponseInitChain {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -5669,7 +5559,7 @@ impl ::protobuf::Message for ResponseInitChain {
                     |m: &ResponseInitChain| { &m.validators },
                     |m: &mut ResponseInitChain| { &mut m.validators },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseInitChain>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseInitChain>(
                     "ResponseInitChain",
                     fields,
                     file_descriptor_proto()
@@ -5679,10 +5569,7 @@ impl ::protobuf::Message for ResponseInitChain {
     }
 
     fn default_instance() -> &'static ResponseInitChain {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseInitChain> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseInitChain,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseInitChain> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseInitChain::new)
         }
@@ -5704,8 +5591,8 @@ impl ::std::fmt::Debug for ResponseInitChain {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseInitChain {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6096,7 +5983,7 @@ impl ::protobuf::Message for ResponseQuery {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -6109,10 +5996,7 @@ impl ::protobuf::Message for ResponseQuery {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -6161,7 +6045,7 @@ impl ::protobuf::Message for ResponseQuery {
                     |m: &ResponseQuery| { &m.codespace },
                     |m: &mut ResponseQuery| { &mut m.codespace },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseQuery>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseQuery>(
                     "ResponseQuery",
                     fields,
                     file_descriptor_proto()
@@ -6171,10 +6055,7 @@ impl ::protobuf::Message for ResponseQuery {
     }
 
     fn default_instance() -> &'static ResponseQuery {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseQuery> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseQuery,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseQuery> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseQuery::new)
         }
@@ -6203,8 +6084,8 @@ impl ::std::fmt::Debug for ResponseQuery {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseQuery {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6320,7 +6201,7 @@ impl ::protobuf::Message for ResponseBeginBlock {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -6333,10 +6214,7 @@ impl ::protobuf::Message for ResponseBeginBlock {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -6345,7 +6223,7 @@ impl ::protobuf::Message for ResponseBeginBlock {
                     |m: &ResponseBeginBlock| { &m.events },
                     |m: &mut ResponseBeginBlock| { &mut m.events },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseBeginBlock>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseBeginBlock>(
                     "ResponseBeginBlock",
                     fields,
                     file_descriptor_proto()
@@ -6355,10 +6233,7 @@ impl ::protobuf::Message for ResponseBeginBlock {
     }
 
     fn default_instance() -> &'static ResponseBeginBlock {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseBeginBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseBeginBlock,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseBeginBlock> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseBeginBlock::new)
         }
@@ -6379,8 +6254,8 @@ impl ::std::fmt::Debug for ResponseBeginBlock {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseBeginBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -6727,7 +6602,7 @@ impl ::protobuf::Message for ResponseCheckTx {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -6740,10 +6615,7 @@ impl ::protobuf::Message for ResponseCheckTx {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -6787,7 +6659,7 @@ impl ::protobuf::Message for ResponseCheckTx {
                     |m: &ResponseCheckTx| { &m.codespace },
                     |m: &mut ResponseCheckTx| { &mut m.codespace },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseCheckTx>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseCheckTx>(
                     "ResponseCheckTx",
                     fields,
                     file_descriptor_proto()
@@ -6797,10 +6669,7 @@ impl ::protobuf::Message for ResponseCheckTx {
     }
 
     fn default_instance() -> &'static ResponseCheckTx {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseCheckTx> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseCheckTx,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseCheckTx> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseCheckTx::new)
         }
@@ -6828,8 +6697,8 @@ impl ::std::fmt::Debug for ResponseCheckTx {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseCheckTx {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7176,7 +7045,7 @@ impl ::protobuf::Message for ResponseDeliverTx {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -7189,10 +7058,7 @@ impl ::protobuf::Message for ResponseDeliverTx {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -7236,7 +7102,7 @@ impl ::protobuf::Message for ResponseDeliverTx {
                     |m: &ResponseDeliverTx| { &m.codespace },
                     |m: &mut ResponseDeliverTx| { &mut m.codespace },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseDeliverTx>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseDeliverTx>(
                     "ResponseDeliverTx",
                     fields,
                     file_descriptor_proto()
@@ -7246,10 +7112,7 @@ impl ::protobuf::Message for ResponseDeliverTx {
     }
 
     fn default_instance() -> &'static ResponseDeliverTx {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseDeliverTx> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseDeliverTx,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseDeliverTx> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseDeliverTx::new)
         }
@@ -7277,8 +7140,8 @@ impl ::std::fmt::Debug for ResponseDeliverTx {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseDeliverTx {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7488,7 +7351,7 @@ impl ::protobuf::Message for ResponseEndBlock {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -7501,10 +7364,7 @@ impl ::protobuf::Message for ResponseEndBlock {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -7523,7 +7383,7 @@ impl ::protobuf::Message for ResponseEndBlock {
                     |m: &ResponseEndBlock| { &m.events },
                     |m: &mut ResponseEndBlock| { &mut m.events },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseEndBlock>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseEndBlock>(
                     "ResponseEndBlock",
                     fields,
                     file_descriptor_proto()
@@ -7533,10 +7393,7 @@ impl ::protobuf::Message for ResponseEndBlock {
     }
 
     fn default_instance() -> &'static ResponseEndBlock {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseEndBlock> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseEndBlock,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseEndBlock> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseEndBlock::new)
         }
@@ -7559,8 +7416,8 @@ impl ::std::fmt::Debug for ResponseEndBlock {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseEndBlock {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7568,6 +7425,7 @@ impl ::protobuf::reflect::ProtobufValue for ResponseEndBlock {
 pub struct ResponseCommit {
     // message fields
     pub data: ::std::vec::Vec<u8>,
+    pub retain_height: i64,
     // special fields
     pub unknown_fields: ::protobuf::UnknownFields,
     pub cached_size: ::protobuf::CachedSize,
@@ -7609,6 +7467,21 @@ impl ResponseCommit {
     pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
         ::std::mem::replace(&mut self.data, ::std::vec::Vec::new())
     }
+
+    // int64 retain_height = 3;
+
+
+    pub fn get_retain_height(&self) -> i64 {
+        self.retain_height
+    }
+    pub fn clear_retain_height(&mut self) {
+        self.retain_height = 0;
+    }
+
+    // Param is passed by value, moved
+    pub fn set_retain_height(&mut self, v: i64) {
+        self.retain_height = v;
+    }
 }
 
 impl ::protobuf::Message for ResponseCommit {
@@ -7623,6 +7496,13 @@ impl ::protobuf::Message for ResponseCommit {
                 2 => {
                     ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.data)?;
                 },
+                3 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_int64()?;
+                    self.retain_height = tmp;
+                },
                 _ => {
                     ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
                 },
@@ -7638,6 +7518,9 @@ impl ::protobuf::Message for ResponseCommit {
         if !self.data.is_empty() {
             my_size += ::protobuf::rt::bytes_size(2, &self.data);
         }
+        if self.retain_height != 0 {
+            my_size += ::protobuf::rt::value_size(3, self.retain_height, ::protobuf::wire_format::WireTypeVarint);
+        }
         my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
         self.cached_size.set(my_size);
         my_size
@@ -7647,6 +7530,9 @@ impl ::protobuf::Message for ResponseCommit {
         if !self.data.is_empty() {
             os.write_bytes(2, &self.data)?;
         }
+        if self.retain_height != 0 {
+            os.write_int64(3, self.retain_height)?;
+        }
         os.write_unknown_fields(self.get_unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -7669,7 +7555,7 @@ impl ::protobuf::Message for ResponseCommit {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -7682,10 +7568,7 @@ impl ::protobuf::Message for ResponseCommit {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -7694,7 +7577,12 @@ impl ::protobuf::Message for ResponseCommit {
                     |m: &ResponseCommit| { &m.data },
                     |m: &mut ResponseCommit| { &mut m.data },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ResponseCommit>(
+                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
+                    "retain_height",
+                    |m: &ResponseCommit| { &m.retain_height },
+                    |m: &mut ResponseCommit| { &mut m.retain_height },
+                ));
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ResponseCommit>(
                     "ResponseCommit",
                     fields,
                     file_descriptor_proto()
@@ -7704,10 +7592,7 @@ impl ::protobuf::Message for ResponseCommit {
     }
 
     fn default_instance() -> &'static ResponseCommit {
-        static mut instance: ::protobuf::lazy::Lazy<ResponseCommit> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ResponseCommit,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ResponseCommit> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ResponseCommit::new)
         }
@@ -7717,6 +7602,7 @@ impl ::protobuf::Message for ResponseCommit {
 impl ::protobuf::Clear for ResponseCommit {
     fn clear(&mut self) {
         self.data.clear();
+        self.retain_height = 0;
         self.unknown_fields.clear();
     }
 }
@@ -7728,8 +7614,8 @@ impl ::std::fmt::Debug for ResponseCommit {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ResponseCommit {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -7955,7 +7841,7 @@ impl ::protobuf::Message for ConsensusParams {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -7968,10 +7854,7 @@ impl ::protobuf::Message for ConsensusParams {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -7990,7 +7873,7 @@ impl ::protobuf::Message for ConsensusParams {
                     |m: &ConsensusParams| { &m.validator },
                     |m: &mut ConsensusParams| { &mut m.validator },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ConsensusParams>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ConsensusParams>(
                     "ConsensusParams",
                     fields,
                     file_descriptor_proto()
@@ -8000,10 +7883,7 @@ impl ::protobuf::Message for ConsensusParams {
     }
 
     fn default_instance() -> &'static ConsensusParams {
-        static mut instance: ::protobuf::lazy::Lazy<ConsensusParams> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ConsensusParams,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ConsensusParams> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ConsensusParams::new)
         }
@@ -8026,8 +7906,8 @@ impl ::std::fmt::Debug for ConsensusParams {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ConsensusParams {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8158,7 +8038,7 @@ impl ::protobuf::Message for BlockParams {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -8171,10 +8051,7 @@ impl ::protobuf::Message for BlockParams {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -8188,7 +8065,7 @@ impl ::protobuf::Message for BlockParams {
                     |m: &BlockParams| { &m.max_gas },
                     |m: &mut BlockParams| { &mut m.max_gas },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<BlockParams>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<BlockParams>(
                     "BlockParams",
                     fields,
                     file_descriptor_proto()
@@ -8198,10 +8075,7 @@ impl ::protobuf::Message for BlockParams {
     }
 
     fn default_instance() -> &'static BlockParams {
-        static mut instance: ::protobuf::lazy::Lazy<BlockParams> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const BlockParams,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<BlockParams> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(BlockParams::new)
         }
@@ -8223,8 +8097,8 @@ impl ::std::fmt::Debug for BlockParams {
 }
 
 impl ::protobuf::reflect::ProtobufValue for BlockParams {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8377,7 +8251,7 @@ impl ::protobuf::Message for EvidenceParams {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -8390,10 +8264,7 @@ impl ::protobuf::Message for EvidenceParams {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -8407,7 +8278,7 @@ impl ::protobuf::Message for EvidenceParams {
                     |m: &EvidenceParams| { &m.max_age_duration },
                     |m: &mut EvidenceParams| { &mut m.max_age_duration },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<EvidenceParams>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<EvidenceParams>(
                     "EvidenceParams",
                     fields,
                     file_descriptor_proto()
@@ -8417,10 +8288,7 @@ impl ::protobuf::Message for EvidenceParams {
     }
 
     fn default_instance() -> &'static EvidenceParams {
-        static mut instance: ::protobuf::lazy::Lazy<EvidenceParams> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const EvidenceParams,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<EvidenceParams> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(EvidenceParams::new)
         }
@@ -8442,8 +8310,8 @@ impl ::std::fmt::Debug for EvidenceParams {
 }
 
 impl ::protobuf::reflect::ProtobufValue for EvidenceParams {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8551,7 +8419,7 @@ impl ::protobuf::Message for ValidatorParams {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -8564,10 +8432,7 @@ impl ::protobuf::Message for ValidatorParams {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -8576,7 +8441,7 @@ impl ::protobuf::Message for ValidatorParams {
                     |m: &ValidatorParams| { &m.pub_key_types },
                     |m: &mut ValidatorParams| { &mut m.pub_key_types },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ValidatorParams>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidatorParams>(
                     "ValidatorParams",
                     fields,
                     file_descriptor_proto()
@@ -8586,10 +8451,7 @@ impl ::protobuf::Message for ValidatorParams {
     }
 
     fn default_instance() -> &'static ValidatorParams {
-        static mut instance: ::protobuf::lazy::Lazy<ValidatorParams> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ValidatorParams,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ValidatorParams> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ValidatorParams::new)
         }
@@ -8610,8 +8472,8 @@ impl ::std::fmt::Debug for ValidatorParams {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ValidatorParams {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8756,7 +8618,7 @@ impl ::protobuf::Message for LastCommitInfo {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -8769,10 +8631,7 @@ impl ::protobuf::Message for LastCommitInfo {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -8786,7 +8645,7 @@ impl ::protobuf::Message for LastCommitInfo {
                     |m: &LastCommitInfo| { &m.votes },
                     |m: &mut LastCommitInfo| { &mut m.votes },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<LastCommitInfo>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<LastCommitInfo>(
                     "LastCommitInfo",
                     fields,
                     file_descriptor_proto()
@@ -8796,10 +8655,7 @@ impl ::protobuf::Message for LastCommitInfo {
     }
 
     fn default_instance() -> &'static LastCommitInfo {
-        static mut instance: ::protobuf::lazy::Lazy<LastCommitInfo> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const LastCommitInfo,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<LastCommitInfo> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(LastCommitInfo::new)
         }
@@ -8821,8 +8677,8 @@ impl ::std::fmt::Debug for LastCommitInfo {
 }
 
 impl ::protobuf::reflect::ProtobufValue for LastCommitInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -8974,7 +8830,7 @@ impl ::protobuf::Message for Event {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -8987,10 +8843,7 @@ impl ::protobuf::Message for Event {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -9004,7 +8857,7 @@ impl ::protobuf::Message for Event {
                     |m: &Event| { &m.attributes },
                     |m: &mut Event| { &mut m.attributes },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Event>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Event>(
                     "Event",
                     fields,
                     file_descriptor_proto()
@@ -9014,10 +8867,7 @@ impl ::protobuf::Message for Event {
     }
 
     fn default_instance() -> &'static Event {
-        static mut instance: ::protobuf::lazy::Lazy<Event> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Event,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Event> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Event::new)
         }
@@ -9039,8 +8889,8 @@ impl ::std::fmt::Debug for Event {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Event {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -9655,7 +9505,7 @@ impl ::protobuf::Message for Header {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -9668,10 +9518,7 @@ impl ::protobuf::Message for Header {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -9745,7 +9592,7 @@ impl ::protobuf::Message for Header {
                     |m: &Header| { &m.proposer_address },
                     |m: &mut Header| { &mut m.proposer_address },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Header>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Header>(
                     "Header",
                     fields,
                     file_descriptor_proto()
@@ -9755,10 +9602,7 @@ impl ::protobuf::Message for Header {
     }
 
     fn default_instance() -> &'static Header {
-        static mut instance: ::protobuf::lazy::Lazy<Header> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Header,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Header> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Header::new)
         }
@@ -9792,8 +9636,8 @@ impl ::std::fmt::Debug for Header {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Header {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -9924,7 +9768,7 @@ impl ::protobuf::Message for Version {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -9937,10 +9781,7 @@ impl ::protobuf::Message for Version {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -9954,7 +9795,7 @@ impl ::protobuf::Message for Version {
                     |m: &Version| { &m.App },
                     |m: &mut Version| { &mut m.App },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Version>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Version>(
                     "Version",
                     fields,
                     file_descriptor_proto()
@@ -9964,10 +9805,7 @@ impl ::protobuf::Message for Version {
     }
 
     fn default_instance() -> &'static Version {
-        static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Version,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Version> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Version::new)
         }
@@ -9989,8 +9827,8 @@ impl ::std::fmt::Debug for Version {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Version {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -10150,7 +9988,7 @@ impl ::protobuf::Message for BlockID {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -10163,10 +10001,7 @@ impl ::protobuf::Message for BlockID {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -10180,7 +10015,7 @@ impl ::protobuf::Message for BlockID {
                     |m: &BlockID| { &m.parts_header },
                     |m: &mut BlockID| { &mut m.parts_header },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<BlockID>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<BlockID>(
                     "BlockID",
                     fields,
                     file_descriptor_proto()
@@ -10190,10 +10025,7 @@ impl ::protobuf::Message for BlockID {
     }
 
     fn default_instance() -> &'static BlockID {
-        static mut instance: ::protobuf::lazy::Lazy<BlockID> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const BlockID,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<BlockID> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(BlockID::new)
         }
@@ -10215,8 +10047,8 @@ impl ::std::fmt::Debug for BlockID {
 }
 
 impl ::protobuf::reflect::ProtobufValue for BlockID {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -10354,7 +10186,7 @@ impl ::protobuf::Message for PartSetHeader {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -10367,10 +10199,7 @@ impl ::protobuf::Message for PartSetHeader {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -10384,7 +10213,7 @@ impl ::protobuf::Message for PartSetHeader {
                     |m: &PartSetHeader| { &m.hash },
                     |m: &mut PartSetHeader| { &mut m.hash },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<PartSetHeader>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<PartSetHeader>(
                     "PartSetHeader",
                     fields,
                     file_descriptor_proto()
@@ -10394,10 +10223,7 @@ impl ::protobuf::Message for PartSetHeader {
     }
 
     fn default_instance() -> &'static PartSetHeader {
-        static mut instance: ::protobuf::lazy::Lazy<PartSetHeader> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const PartSetHeader,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<PartSetHeader> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(PartSetHeader::new)
         }
@@ -10419,8 +10245,8 @@ impl ::std::fmt::Debug for PartSetHeader {
 }
 
 impl ::protobuf::reflect::ProtobufValue for PartSetHeader {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -10558,7 +10384,7 @@ impl ::protobuf::Message for Validator {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -10571,10 +10397,7 @@ impl ::protobuf::Message for Validator {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -10588,7 +10411,7 @@ impl ::protobuf::Message for Validator {
                     |m: &Validator| { &m.power },
                     |m: &mut Validator| { &mut m.power },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Validator>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Validator>(
                     "Validator",
                     fields,
                     file_descriptor_proto()
@@ -10598,10 +10421,7 @@ impl ::protobuf::Message for Validator {
     }
 
     fn default_instance() -> &'static Validator {
-        static mut instance: ::protobuf::lazy::Lazy<Validator> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Validator,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Validator> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Validator::new)
         }
@@ -10623,8 +10443,8 @@ impl ::std::fmt::Debug for Validator {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Validator {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -10777,7 +10597,7 @@ impl ::protobuf::Message for ValidatorUpdate {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -10790,10 +10610,7 @@ impl ::protobuf::Message for ValidatorUpdate {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -10807,7 +10624,7 @@ impl ::protobuf::Message for ValidatorUpdate {
                     |m: &ValidatorUpdate| { &m.power },
                     |m: &mut ValidatorUpdate| { &mut m.power },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ValidatorUpdate>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ValidatorUpdate>(
                     "ValidatorUpdate",
                     fields,
                     file_descriptor_proto()
@@ -10817,10 +10634,7 @@ impl ::protobuf::Message for ValidatorUpdate {
     }
 
     fn default_instance() -> &'static ValidatorUpdate {
-        static mut instance: ::protobuf::lazy::Lazy<ValidatorUpdate> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ValidatorUpdate,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ValidatorUpdate> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ValidatorUpdate::new)
         }
@@ -10842,8 +10656,8 @@ impl ::std::fmt::Debug for ValidatorUpdate {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ValidatorUpdate {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -10996,7 +10810,7 @@ impl ::protobuf::Message for VoteInfo {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -11009,10 +10823,7 @@ impl ::protobuf::Message for VoteInfo {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -11026,7 +10837,7 @@ impl ::protobuf::Message for VoteInfo {
                     |m: &VoteInfo| { &m.signed_last_block },
                     |m: &mut VoteInfo| { &mut m.signed_last_block },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<VoteInfo>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<VoteInfo>(
                     "VoteInfo",
                     fields,
                     file_descriptor_proto()
@@ -11036,10 +10847,7 @@ impl ::protobuf::Message for VoteInfo {
     }
 
     fn default_instance() -> &'static VoteInfo {
-        static mut instance: ::protobuf::lazy::Lazy<VoteInfo> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const VoteInfo,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<VoteInfo> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(VoteInfo::new)
         }
@@ -11061,8 +10869,8 @@ impl ::std::fmt::Debug for VoteInfo {
 }
 
 impl ::protobuf::reflect::ProtobufValue for VoteInfo {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -11207,7 +11015,7 @@ impl ::protobuf::Message for PubKey {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -11220,10 +11028,7 @@ impl ::protobuf::Message for PubKey {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -11237,7 +11042,7 @@ impl ::protobuf::Message for PubKey {
                     |m: &PubKey| { &m.data },
                     |m: &mut PubKey| { &mut m.data },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<PubKey>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<PubKey>(
                     "PubKey",
                     fields,
                     file_descriptor_proto()
@@ -11247,10 +11052,7 @@ impl ::protobuf::Message for PubKey {
     }
 
     fn default_instance() -> &'static PubKey {
-        static mut instance: ::protobuf::lazy::Lazy<PubKey> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const PubKey,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<PubKey> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(PubKey::new)
         }
@@ -11272,8 +11074,8 @@ impl ::std::fmt::Debug for PubKey {
 }
 
 impl ::protobuf::reflect::ProtobufValue for PubKey {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -11542,7 +11344,7 @@ impl ::protobuf::Message for Evidence {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -11555,10 +11357,7 @@ impl ::protobuf::Message for Evidence {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -11587,7 +11386,7 @@ impl ::protobuf::Message for Evidence {
                     |m: &Evidence| { &m.total_voting_power },
                     |m: &mut Evidence| { &mut m.total_voting_power },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Evidence>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Evidence>(
                     "Evidence",
                     fields,
                     file_descriptor_proto()
@@ -11597,10 +11396,7 @@ impl ::protobuf::Message for Evidence {
     }
 
     fn default_instance() -> &'static Evidence {
-        static mut instance: ::protobuf::lazy::Lazy<Evidence> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Evidence,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Evidence> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Evidence::new)
         }
@@ -11625,8 +11421,8 @@ impl ::std::fmt::Debug for Evidence {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Evidence {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -11658,13 +11454,10 @@ impl ::protobuf::ProtobufEnum for CheckTxType {
     }
 
     fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::EnumDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
-                ::protobuf::reflect::EnumDescriptor::new("CheckTxType", file_descriptor_proto())
+                ::protobuf::reflect::EnumDescriptor::new_pb_name::<CheckTxType>("CheckTxType", file_descriptor_proto())
             })
         }
     }
@@ -11680,8 +11473,8 @@ impl ::std::default::Default for CheckTxType {
 }
 
 impl ::protobuf::reflect::ProtobufValue for CheckTxType {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor())
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Enum(self.descriptor())
     }
 }
 
@@ -11706,15 +11499,15 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     \x15\n\x0bp2p_version\x18\x03\x20\x01(\x04B\0:\0\"4\n\x10RequestSetOptio\
     n\x12\r\n\x03key\x18\x01\x20\x01(\tB\0\x12\x0f\n\x05value\x18\x02\x20\
     \x01(\tB\0:\0\"\xfd\x01\n\x10RequestInitChain\x122\n\x04time\x18\x01\x20\
-    \x01(\x0b2\x1a.google.protobuf.TimestampB\x08\x90\xdf\x1f\x01\xc8\xde\
-    \x1f\0\x12\x12\n\x08chain_id\x18\x02\x20\x01(\tB\0\x12B\n\x10consensus_p\
-    arams\x18\x03\x20\x01(\x0b2&.tendermint.abci.types.ConsensusParamsB\0\
-    \x12@\n\nvalidators\x18\x04\x20\x03(\x0b2&.tendermint.abci.types.Validat\
-    orUpdateB\x04\xc8\xde\x1f\0\x12\x19\n\x0fapp_state_bytes\x18\x05\x20\x01\
-    (\x0cB\0:\0\"S\n\x0cRequestQuery\x12\x0e\n\x04data\x18\x01\x20\x01(\x0cB\
-    \0\x12\x0e\n\x04path\x18\x02\x20\x01(\tB\0\x12\x10\n\x06height\x18\x03\
-    \x20\x01(\x03B\0\x12\x0f\n\x05prove\x18\x04\x20\x01(\x08B\0:\0\"\xe6\x01\
-    \n\x11RequestBeginBlock\x12\x0e\n\x04hash\x18\x01\x20\x01(\x0cB\0\x123\n\
+    \x01(\x0b2\x1a.google.protobuf.TimestampB\x08\xc8\xde\x1f\0\x90\xdf\x1f\
+    \x01\x12\x12\n\x08chain_id\x18\x02\x20\x01(\tB\0\x12B\n\x10consensus_par\
+    ams\x18\x03\x20\x01(\x0b2&.tendermint.abci.types.ConsensusParamsB\0\x12@\
+    \n\nvalidators\x18\x04\x20\x03(\x0b2&.tendermint.abci.types.ValidatorUpd\
+    ateB\x04\xc8\xde\x1f\0\x12\x19\n\x0fapp_state_bytes\x18\x05\x20\x01(\x0c\
+    B\0:\0\"S\n\x0cRequestQuery\x12\x0e\n\x04data\x18\x01\x20\x01(\x0cB\0\
+    \x12\x0e\n\x04path\x18\x02\x20\x01(\tB\0\x12\x10\n\x06height\x18\x03\x20\
+    \x01(\x03B\0\x12\x0f\n\x05prove\x18\x04\x20\x01(\x08B\0:\0\"\xe6\x01\n\
+    \x11RequestBeginBlock\x12\x0e\n\x04hash\x18\x01\x20\x01(\x0cB\0\x123\n\
     \x06header\x18\x02\x20\x01(\x0b2\x1d.tendermint.abci.types.HeaderB\x04\
     \xc8\xde\x1f\0\x12E\n\x10last_commit_info\x18\x03\x20\x01(\x0b2%.tenderm\
     int.abci.types.LastCommitInfoB\x04\xc8\xde\x1f\0\x12C\n\x14byzantine_val\
@@ -11757,79 +11550,77 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     2\x1f.tendermint.crypto.merkle.ProofB\0\x12\x10\n\x06height\x18\t\x20\
     \x01(\x03B\0\x12\x13\n\tcodespace\x18\n\x20\x01(\tB\0:\0\"^\n\x12Respons\
     eBeginBlock\x12F\n\x06events\x18\x01\x20\x03(\x0b2\x1c.tendermint.abci.t\
-    ypes.EventB\x18\xea\xde\x1f\x10events,omitempty\xc8\xde\x1f\0:\0\"\xd9\
+    ypes.EventB\x18\xc8\xde\x1f\0\xea\xde\x1f\x10events,omitempty:\0\"\xd9\
     \x01\n\x0fResponseCheckTx\x12\x0e\n\x04code\x18\x01\x20\x01(\rB\0\x12\
     \x0e\n\x04data\x18\x02\x20\x01(\x0cB\0\x12\r\n\x03log\x18\x03\x20\x01(\t\
     B\0\x12\x0e\n\x04info\x18\x04\x20\x01(\tB\0\x12\x14\n\ngas_wanted\x18\
     \x05\x20\x01(\x03B\0\x12\x12\n\x08gas_used\x18\x06\x20\x01(\x03B\0\x12F\
     \n\x06events\x18\x07\x20\x03(\x0b2\x1c.tendermint.abci.types.EventB\x18\
-    \xea\xde\x1f\x10events,omitempty\xc8\xde\x1f\0\x12\x13\n\tcodespace\x18\
+    \xc8\xde\x1f\0\xea\xde\x1f\x10events,omitempty\x12\x13\n\tcodespace\x18\
     \x08\x20\x01(\tB\0:\0\"\xdb\x01\n\x11ResponseDeliverTx\x12\x0e\n\x04code\
     \x18\x01\x20\x01(\rB\0\x12\x0e\n\x04data\x18\x02\x20\x01(\x0cB\0\x12\r\n\
     \x03log\x18\x03\x20\x01(\tB\0\x12\x0e\n\x04info\x18\x04\x20\x01(\tB\0\
     \x12\x14\n\ngas_wanted\x18\x05\x20\x01(\x03B\0\x12\x12\n\x08gas_used\x18\
     \x06\x20\x01(\x03B\0\x12F\n\x06events\x18\x07\x20\x03(\x0b2\x1c.tendermi\
-    nt.abci.types.EventB\x18\xc8\xde\x1f\0\xea\xde\x1f\x10events,omitempty\
+    nt.abci.types.EventB\x18\xea\xde\x1f\x10events,omitempty\xc8\xde\x1f\0\
     \x12\x13\n\tcodespace\x18\x08\x20\x01(\tB\0:\0\"\xf0\x01\n\x10ResponseEn\
     dBlock\x12G\n\x11validator_updates\x18\x01\x20\x03(\x0b2&.tendermint.abc\
     i.types.ValidatorUpdateB\x04\xc8\xde\x1f\0\x12I\n\x17consensus_param_upd\
     ates\x18\x02\x20\x01(\x0b2&.tendermint.abci.types.ConsensusParamsB\0\x12\
     F\n\x06events\x18\x03\x20\x03(\x0b2\x1c.tendermint.abci.types.EventB\x18\
-    \xc8\xde\x1f\0\xea\xde\x1f\x10events,omitempty:\0\"\"\n\x0eResponseCommi\
-    t\x12\x0e\n\x04data\x18\x02\x20\x01(\x0cB\0:\0\"\xc0\x01\n\x0fConsensusP\
-    arams\x123\n\x05block\x18\x01\x20\x01(\x0b2\".tendermint.abci.types.Bloc\
-    kParamsB\0\x129\n\x08evidence\x18\x02\x20\x01(\x0b2%.tendermint.abci.typ\
-    es.EvidenceParamsB\0\x12;\n\tvalidator\x18\x03\x20\x01(\x0b2&.tendermint\
-    .abci.types.ValidatorParamsB\0:\0\"7\n\x0bBlockParams\x12\x13\n\tmax_byt\
-    es\x18\x01\x20\x01(\x03B\0\x12\x11\n\x07max_gas\x18\x02\x20\x01(\x03B\0:\
-    \0\"o\n\x0eEvidenceParams\x12\x1c\n\x12max_age_num_blocks\x18\x01\x20\
-    \x01(\x03B\0\x12=\n\x10max_age_duration\x18\x02\x20\x01(\x0b2\x19.google\
-    .protobuf.DurationB\x08\x98\xdf\x1f\x01\xc8\xde\x1f\0:\0\",\n\x0fValidat\
-    orParams\x12\x17\n\rpub_key_types\x18\x01\x20\x03(\tB\0:\0\"Y\n\x0eLastC\
-    ommitInfo\x12\x0f\n\x05round\x18\x01\x20\x01(\x05B\0\x124\n\x05votes\x18\
-    \x02\x20\x03(\x0b2\x1f.tendermint.abci.types.VoteInfoB\x04\xc8\xde\x1f\0\
-    :\0\"e\n\x05Event\x12\x0e\n\x04type\x18\x01\x20\x01(\tB\0\x12J\n\nattrib\
-    utes\x18\x02\x20\x03(\x0b2\x18.tendermint.libs.kv.PairB\x1c\xea\xde\x1f\
-    \x14attributes,omitempty\xc8\xde\x1f\0:\0\"\xcf\x03\n\x06Header\x125\n\
-    \x07version\x18\x01\x20\x01(\x0b2\x1e.tendermint.abci.types.VersionB\x04\
-    \xc8\xde\x1f\0\x12\x1d\n\x08chain_id\x18\x02\x20\x01(\tB\x0b\xe2\xde\x1f\
-    \x07ChainID\x12\x10\n\x06height\x18\x03\x20\x01(\x03B\0\x122\n\x04time\
-    \x18\x04\x20\x01(\x0b2\x1a.google.protobuf.TimestampB\x08\xc8\xde\x1f\0\
-    \x90\xdf\x1f\x01\x12;\n\rlast_block_id\x18\x05\x20\x01(\x0b2\x1e.tenderm\
-    int.abci.types.BlockIDB\x04\xc8\xde\x1f\0\x12\x1a\n\x10last_commit_hash\
-    \x18\x06\x20\x01(\x0cB\0\x12\x13\n\tdata_hash\x18\x07\x20\x01(\x0cB\0\
-    \x12\x19\n\x0fvalidators_hash\x18\x08\x20\x01(\x0cB\0\x12\x1e\n\x14next_\
-    validators_hash\x18\t\x20\x01(\x0cB\0\x12\x18\n\x0econsensus_hash\x18\n\
-    \x20\x01(\x0cB\0\x12\x12\n\x08app_hash\x18\x0b\x20\x01(\x0cB\0\x12\x1b\n\
-    \x11last_results_hash\x18\x0c\x20\x01(\x0cB\0\x12\x17\n\revidence_hash\
-    \x18\r\x20\x01(\x0cB\0\x12\x1a\n\x10proposer_address\x18\x0e\x20\x01(\
-    \x0cB\0:\0\"+\n\x07Version\x12\x0f\n\x05Block\x18\x01\x20\x01(\x04B\0\
-    \x12\r\n\x03App\x18\x02\x20\x01(\x04B\0:\0\"]\n\x07BlockID\x12\x0e\n\x04\
-    hash\x18\x01\x20\x01(\x0cB\0\x12@\n\x0cparts_header\x18\x02\x20\x01(\x0b\
-    2$.tendermint.abci.types.PartSetHeaderB\x04\xc8\xde\x1f\0:\0\"2\n\rPartS\
-    etHeader\x12\x0f\n\x05total\x18\x01\x20\x01(\x05B\0\x12\x0e\n\x04hash\
-    \x18\x02\x20\x01(\x0cB\0:\0\"1\n\tValidator\x12\x11\n\x07address\x18\x01\
-    \x20\x01(\x0cB\0\x12\x0f\n\x05power\x18\x03\x20\x01(\x03B\0:\0\"Z\n\x0fV\
-    alidatorUpdate\x124\n\x07pub_key\x18\x01\x20\x01(\x0b2\x1d.tendermint.ab\
-    ci.types.PubKeyB\x04\xc8\xde\x1f\0\x12\x0f\n\x05power\x18\x02\x20\x01(\
-    \x03B\0:\0\"d\n\x08VoteInfo\x129\n\tvalidator\x18\x01\x20\x01(\x0b2\x20.\
-    tendermint.abci.types.ValidatorB\x04\xc8\xde\x1f\0\x12\x1b\n\x11signed_l\
-    ast_block\x18\x02\x20\x01(\x08B\0:\0\"*\n\x06PubKey\x12\x0e\n\x04type\
-    \x18\x01\x20\x01(\tB\0\x12\x0e\n\x04data\x18\x02\x20\x01(\x0cB\0:\0\"\
-    \xbb\x01\n\x08Evidence\x12\x0e\n\x04type\x18\x01\x20\x01(\tB\0\x129\n\tv\
-    alidator\x18\x02\x20\x01(\x0b2\x20.tendermint.abci.types.ValidatorB\x04\
-    \xc8\xde\x1f\0\x12\x10\n\x06height\x18\x03\x20\x01(\x03B\0\x122\n\x04tim\
-    e\x18\x04\x20\x01(\x0b2\x1a.google.protobuf.TimestampB\x08\x90\xdf\x1f\
-    \x01\xc8\xde\x1f\0\x12\x1c\n\x12total_voting_power\x18\x05\x20\x01(\x03B\
-    \0:\0*%\n\x0bCheckTxType\x12\x07\n\x03New\x10\0\x12\x0b\n\x07Recheck\x10\
-    \x01\x1a\0B\x1c\xb8\xe2\x1e\x01\xc0\xe3\x1e\x01\xc8\xe2\x1e\x01\xe0\xe2\
-    \x1e\x01\xf8\xe1\x1e\x01\xd0\xe2\x1e\x01\xa8\xe2\x1e\x01b\x06proto3\
+    \xea\xde\x1f\x10events,omitempty\xc8\xde\x1f\0:\0\";\n\x0eResponseCommit\
+    \x12\x0e\n\x04data\x18\x02\x20\x01(\x0cB\0\x12\x17\n\rretain_height\x18\
+    \x03\x20\x01(\x03B\0:\0\"\xc0\x01\n\x0fConsensusParams\x123\n\x05block\
+    \x18\x01\x20\x01(\x0b2\".tendermint.abci.types.BlockParamsB\0\x129\n\x08\
+    evidence\x18\x02\x20\x01(\x0b2%.tendermint.abci.types.EvidenceParamsB\0\
+    \x12;\n\tvalidator\x18\x03\x20\x01(\x0b2&.tendermint.abci.types.Validato\
+    rParamsB\0:\0\"7\n\x0bBlockParams\x12\x13\n\tmax_bytes\x18\x01\x20\x01(\
+    \x03B\0\x12\x11\n\x07max_gas\x18\x02\x20\x01(\x03B\0:\0\"o\n\x0eEvidence\
+    Params\x12\x1c\n\x12max_age_num_blocks\x18\x01\x20\x01(\x03B\0\x12=\n\
+    \x10max_age_duration\x18\x02\x20\x01(\x0b2\x19.google.protobuf.DurationB\
+    \x08\x98\xdf\x1f\x01\xc8\xde\x1f\0:\0\",\n\x0fValidatorParams\x12\x17\n\
+    \rpub_key_types\x18\x01\x20\x03(\tB\0:\0\"Y\n\x0eLastCommitInfo\x12\x0f\
+    \n\x05round\x18\x01\x20\x01(\x05B\0\x124\n\x05votes\x18\x02\x20\x03(\x0b\
+    2\x1f.tendermint.abci.types.VoteInfoB\x04\xc8\xde\x1f\0:\0\"e\n\x05Event\
+    \x12\x0e\n\x04type\x18\x01\x20\x01(\tB\0\x12J\n\nattributes\x18\x02\x20\
+    \x03(\x0b2\x18.tendermint.libs.kv.PairB\x1c\xc8\xde\x1f\0\xea\xde\x1f\
+    \x14attributes,omitempty:\0\"\xcf\x03\n\x06Header\x125\n\x07version\x18\
+    \x01\x20\x01(\x0b2\x1e.tendermint.abci.types.VersionB\x04\xc8\xde\x1f\0\
+    \x12\x1d\n\x08chain_id\x18\x02\x20\x01(\tB\x0b\xe2\xde\x1f\x07ChainID\
+    \x12\x10\n\x06height\x18\x03\x20\x01(\x03B\0\x122\n\x04time\x18\x04\x20\
+    \x01(\x0b2\x1a.google.protobuf.TimestampB\x08\x90\xdf\x1f\x01\xc8\xde\
+    \x1f\0\x12;\n\rlast_block_id\x18\x05\x20\x01(\x0b2\x1e.tendermint.abci.t\
+    ypes.BlockIDB\x04\xc8\xde\x1f\0\x12\x1a\n\x10last_commit_hash\x18\x06\
+    \x20\x01(\x0cB\0\x12\x13\n\tdata_hash\x18\x07\x20\x01(\x0cB\0\x12\x19\n\
+    \x0fvalidators_hash\x18\x08\x20\x01(\x0cB\0\x12\x1e\n\x14next_validators\
+    _hash\x18\t\x20\x01(\x0cB\0\x12\x18\n\x0econsensus_hash\x18\n\x20\x01(\
+    \x0cB\0\x12\x12\n\x08app_hash\x18\x0b\x20\x01(\x0cB\0\x12\x1b\n\x11last_\
+    results_hash\x18\x0c\x20\x01(\x0cB\0\x12\x17\n\revidence_hash\x18\r\x20\
+    \x01(\x0cB\0\x12\x1a\n\x10proposer_address\x18\x0e\x20\x01(\x0cB\0:\0\"+\
+    \n\x07Version\x12\x0f\n\x05Block\x18\x01\x20\x01(\x04B\0\x12\r\n\x03App\
+    \x18\x02\x20\x01(\x04B\0:\0\"]\n\x07BlockID\x12\x0e\n\x04hash\x18\x01\
+    \x20\x01(\x0cB\0\x12@\n\x0cparts_header\x18\x02\x20\x01(\x0b2$.tendermin\
+    t.abci.types.PartSetHeaderB\x04\xc8\xde\x1f\0:\0\"2\n\rPartSetHeader\x12\
+    \x0f\n\x05total\x18\x01\x20\x01(\x05B\0\x12\x0e\n\x04hash\x18\x02\x20\
+    \x01(\x0cB\0:\0\"1\n\tValidator\x12\x11\n\x07address\x18\x01\x20\x01(\
+    \x0cB\0\x12\x0f\n\x05power\x18\x03\x20\x01(\x03B\0:\0\"Z\n\x0fValidatorU\
+    pdate\x124\n\x07pub_key\x18\x01\x20\x01(\x0b2\x1d.tendermint.abci.types.\
+    PubKeyB\x04\xc8\xde\x1f\0\x12\x0f\n\x05power\x18\x02\x20\x01(\x03B\0:\0\
+    \"d\n\x08VoteInfo\x129\n\tvalidator\x18\x01\x20\x01(\x0b2\x20.tendermint\
+    .abci.types.ValidatorB\x04\xc8\xde\x1f\0\x12\x1b\n\x11signed_last_block\
+    \x18\x02\x20\x01(\x08B\0:\0\"*\n\x06PubKey\x12\x0e\n\x04type\x18\x01\x20\
+    \x01(\tB\0\x12\x0e\n\x04data\x18\x02\x20\x01(\x0cB\0:\0\"\xbb\x01\n\x08E\
+    vidence\x12\x0e\n\x04type\x18\x01\x20\x01(\tB\0\x129\n\tvalidator\x18\
+    \x02\x20\x01(\x0b2\x20.tendermint.abci.types.ValidatorB\x04\xc8\xde\x1f\
+    \0\x12\x10\n\x06height\x18\x03\x20\x01(\x03B\0\x122\n\x04time\x18\x04\
+    \x20\x01(\x0b2\x1a.google.protobuf.TimestampB\x08\xc8\xde\x1f\0\x90\xdf\
+    \x1f\x01\x12\x1c\n\x12total_voting_power\x18\x05\x20\x01(\x03B\0:\0*%\n\
+    \x0bCheckTxType\x12\x07\n\x03New\x10\0\x12\x0b\n\x07Recheck\x10\x01\x1a\
+    \0B\x1c\xd0\xe2\x1e\x01\xb8\xe2\x1e\x01\xc0\xe3\x1e\x01\xe0\xe2\x1e\x01\
+    \xc8\xe2\x1e\x01\xf8\xe1\x1e\x01\xa8\xe2\x1e\x01b\x06proto3\
 ";
 
-static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
-    lock: ::protobuf::lazy::ONCE_INIT,
-    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
-};
+static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
 
 fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
     ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
diff --git a/src/messages/merkle.rs b/src/messages/merkle.rs
index 0d4da96..22d7b3e 100644
--- a/src/messages/merkle.rs
+++ b/src/messages/merkle.rs
@@ -1,11 +1,12 @@
-// This file is generated by rust-protobuf 2.10.2. Do not edit
+// This file is generated by rust-protobuf 2.15.1. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
-#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_attributes)]
+#![rustfmt::skip]
 
 #![allow(box_pointers)]
 #![allow(dead_code)]
@@ -24,7 +25,7 @@ use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
 
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_2;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_15_1;
 
 #[derive(PartialEq,Clone,Default)]
 pub struct ProofOp {
@@ -203,7 +204,7 @@ impl ::protobuf::Message for ProofOp {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -216,10 +217,7 @@ impl ::protobuf::Message for ProofOp {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -238,7 +236,7 @@ impl ::protobuf::Message for ProofOp {
                     |m: &ProofOp| { &m.data },
                     |m: &mut ProofOp| { &mut m.data },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<ProofOp>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<ProofOp>(
                     "ProofOp",
                     fields,
                     file_descriptor_proto()
@@ -248,10 +246,7 @@ impl ::protobuf::Message for ProofOp {
     }
 
     fn default_instance() -> &'static ProofOp {
-        static mut instance: ::protobuf::lazy::Lazy<ProofOp> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ProofOp,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<ProofOp> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(ProofOp::new)
         }
@@ -274,8 +269,8 @@ impl ::std::fmt::Debug for ProofOp {
 }
 
 impl ::protobuf::reflect::ProtobufValue for ProofOp {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -391,7 +386,7 @@ impl ::protobuf::Message for Proof {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -404,10 +399,7 @@ impl ::protobuf::Message for Proof {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -416,7 +408,7 @@ impl ::protobuf::Message for Proof {
                     |m: &Proof| { &m.ops },
                     |m: &mut Proof| { &mut m.ops },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Proof>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Proof>(
                     "Proof",
                     fields,
                     file_descriptor_proto()
@@ -426,10 +418,7 @@ impl ::protobuf::Message for Proof {
     }
 
     fn default_instance() -> &'static Proof {
-        static mut instance: ::protobuf::lazy::Lazy<Proof> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Proof,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Proof> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Proof::new)
         }
@@ -450,8 +439,8 @@ impl ::std::fmt::Debug for Proof {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Proof {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
@@ -460,14 +449,11 @@ static file_descriptor_proto_data: &'static [u8] = b"\
     \x07ProofOp\x12\x0e\n\x04type\x18\x01\x20\x01(\tB\0\x12\r\n\x03key\x18\
     \x02\x20\x01(\x0cB\0\x12\x0e\n\x04data\x18\x03\x20\x01(\x0cB\0:\0\"?\n\
     \x05Proof\x124\n\x03ops\x18\x01\x20\x03(\x0b2!.tendermint.crypto.merkle.\
-    ProofOpB\x04\xc8\xde\x1f\0:\0B\x14\xc8\xe2\x1e\x01\xd0\xe2\x1e\x01\xf8\
-    \xe1\x1e\x01\xa8\xe2\x1e\x01\xe0\xe2\x1e\x01b\x06proto3\
+    ProofOpB\x04\xc8\xde\x1f\0:\0B\x14\xd0\xe2\x1e\x01\xf8\xe1\x1e\x01\xa8\
+    \xe2\x1e\x01\xc8\xe2\x1e\x01\xe0\xe2\x1e\x01b\x06proto3\
 ";
 
-static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
-    lock: ::protobuf::lazy::ONCE_INIT,
-    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
-};
+static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
 
 fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
     ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
diff --git a/src/messages/types.rs b/src/messages/types.rs
index 72c4195..4357f46 100644
--- a/src/messages/types.rs
+++ b/src/messages/types.rs
@@ -1,11 +1,12 @@
-// This file is generated by rust-protobuf 2.10.2. Do not edit
+// This file is generated by rust-protobuf 2.15.1. Do not edit
 // @generated
 
 // https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
-#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_attributes)]
+#![rustfmt::skip]
 
 #![allow(box_pointers)]
 #![allow(dead_code)]
@@ -24,7 +25,7 @@ use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
 
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_2;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_15_1;
 
 #[derive(PartialEq,Clone,Default)]
 pub struct Pair {
@@ -167,7 +168,7 @@ impl ::protobuf::Message for Pair {
     fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
         self as &mut dyn (::std::any::Any)
     }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
+    fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
         self
     }
 
@@ -180,10 +181,7 @@ impl ::protobuf::Message for Pair {
     }
 
     fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
+        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             descriptor.get(|| {
                 let mut fields = ::std::vec::Vec::new();
@@ -197,7 +195,7 @@ impl ::protobuf::Message for Pair {
                     |m: &Pair| { &m.value },
                     |m: &mut Pair| { &mut m.value },
                 ));
-                ::protobuf::reflect::MessageDescriptor::new::<Pair>(
+                ::protobuf::reflect::MessageDescriptor::new_pb_name::<Pair>(
                     "Pair",
                     fields,
                     file_descriptor_proto()
@@ -207,10 +205,7 @@ impl ::protobuf::Message for Pair {
     }
 
     fn default_instance() -> &'static Pair {
-        static mut instance: ::protobuf::lazy::Lazy<Pair> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const Pair,
-        };
+        static mut instance: ::protobuf::lazy::Lazy<Pair> = ::protobuf::lazy::Lazy::INIT;
         unsafe {
             instance.get(Pair::new)
         }
@@ -232,228 +227,19 @@ impl ::std::fmt::Debug for Pair {
 }
 
 impl ::protobuf::reflect::ProtobufValue for Pair {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
-    }
-}
-
-#[derive(PartialEq,Clone,Default)]
-pub struct KI64Pair {
-    // message fields
-    pub key: ::std::vec::Vec<u8>,
-    pub value: i64,
-    // special fields
-    pub unknown_fields: ::protobuf::UnknownFields,
-    pub cached_size: ::protobuf::CachedSize,
-}
-
-impl<'a> ::std::default::Default for &'a KI64Pair {
-    fn default() -> &'a KI64Pair {
-        <KI64Pair as ::protobuf::Message>::default_instance()
-    }
-}
-
-impl KI64Pair {
-    pub fn new() -> KI64Pair {
-        ::std::default::Default::default()
-    }
-
-    // bytes key = 1;
-
-
-    pub fn get_key(&self) -> &[u8] {
-        &self.key
-    }
-    pub fn clear_key(&mut self) {
-        self.key.clear();
-    }
-
-    // Param is passed by value, moved
-    pub fn set_key(&mut self, v: ::std::vec::Vec<u8>) {
-        self.key = v;
-    }
-
-    // Mutable pointer to the field.
-    // If field is not initialized, it is initialized with default value first.
-    pub fn mut_key(&mut self) -> &mut ::std::vec::Vec<u8> {
-        &mut self.key
-    }
-
-    // Take field
-    pub fn take_key(&mut self) -> ::std::vec::Vec<u8> {
-        ::std::mem::replace(&mut self.key, ::std::vec::Vec::new())
-    }
-
-    // int64 value = 2;
-
-
-    pub fn get_value(&self) -> i64 {
-        self.value
-    }
-    pub fn clear_value(&mut self) {
-        self.value = 0;
-    }
-
-    // Param is passed by value, moved
-    pub fn set_value(&mut self, v: i64) {
-        self.value = v;
-    }
-}
-
-impl ::protobuf::Message for KI64Pair {
-    fn is_initialized(&self) -> bool {
-        true
-    }
-
-    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
-        while !is.eof()? {
-            let (field_number, wire_type) = is.read_tag_unpack()?;
-            match field_number {
-                1 => {
-                    ::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.key)?;
-                },
-                2 => {
-                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
-                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
-                    }
-                    let tmp = is.read_int64()?;
-                    self.value = tmp;
-                },
-                _ => {
-                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
-                },
-            };
-        }
-        ::std::result::Result::Ok(())
-    }
-
-    // Compute sizes of nested messages
-    #[allow(unused_variables)]
-    fn compute_size(&self) -> u32 {
-        let mut my_size = 0;
-        if !self.key.is_empty() {
-            my_size += ::protobuf::rt::bytes_size(1, &self.key);
-        }
-        if self.value != 0 {
-            my_size += ::protobuf::rt::value_size(2, self.value, ::protobuf::wire_format::WireTypeVarint);
-        }
-        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
-        self.cached_size.set(my_size);
-        my_size
-    }
-
-    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
-        if !self.key.is_empty() {
-            os.write_bytes(1, &self.key)?;
-        }
-        if self.value != 0 {
-            os.write_int64(2, self.value)?;
-        }
-        os.write_unknown_fields(self.get_unknown_fields())?;
-        ::std::result::Result::Ok(())
-    }
-
-    fn get_cached_size(&self) -> u32 {
-        self.cached_size.get()
-    }
-
-    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
-        &self.unknown_fields
-    }
-
-    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
-        &mut self.unknown_fields
-    }
-
-    fn as_any(&self) -> &dyn (::std::any::Any) {
-        self as &dyn (::std::any::Any)
-    }
-    fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
-        self as &mut dyn (::std::any::Any)
-    }
-    fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
-        self
-    }
-
-    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
-        Self::descriptor_static()
-    }
-
-    fn new() -> KI64Pair {
-        KI64Pair::new()
-    }
-
-    fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
-        static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const ::protobuf::reflect::MessageDescriptor,
-        };
-        unsafe {
-            descriptor.get(|| {
-                let mut fields = ::std::vec::Vec::new();
-                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
-                    "key",
-                    |m: &KI64Pair| { &m.key },
-                    |m: &mut KI64Pair| { &mut m.key },
-                ));
-                fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeInt64>(
-                    "value",
-                    |m: &KI64Pair| { &m.value },
-                    |m: &mut KI64Pair| { &mut m.value },
-                ));
-                ::protobuf::reflect::MessageDescriptor::new::<KI64Pair>(
-                    "KI64Pair",
-                    fields,
-                    file_descriptor_proto()
-                )
-            })
-        }
-    }
-
-    fn default_instance() -> &'static KI64Pair {
-        static mut instance: ::protobuf::lazy::Lazy<KI64Pair> = ::protobuf::lazy::Lazy {
-            lock: ::protobuf::lazy::ONCE_INIT,
-            ptr: 0 as *const KI64Pair,
-        };
-        unsafe {
-            instance.get(KI64Pair::new)
-        }
-    }
-}
-
-impl ::protobuf::Clear for KI64Pair {
-    fn clear(&mut self) {
-        self.key.clear();
-        self.value = 0;
-        self.unknown_fields.clear();
-    }
-}
-
-impl ::std::fmt::Debug for KI64Pair {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-        ::protobuf::text_format::fmt(self, f)
-    }
-}
-
-impl ::protobuf::reflect::ProtobufValue for KI64Pair {
-    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
-        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
+        ::protobuf::reflect::ReflectValueRef::Message(self)
     }
 }
 
 static file_descriptor_proto_data: &'static [u8] = b"\
     \n\x13libs/kv/types.proto\x12\x12tendermint.libs.kv\"(\n\x04Pair\x12\r\n\
     \x03key\x18\x01\x20\x01(\x0cB\0\x12\x0f\n\x05value\x18\x02\x20\x01(\x0cB\
-    \0:\0\",\n\x08KI64Pair\x12\r\n\x03key\x18\x01\x20\x01(\x0cB\0\x12\x0f\n\
-    \x05value\x18\x02\x20\x01(\x03B\0:\0B\x1c\xe0\xe2\x1e\x01\xc0\xe3\x1e\
-    \x01\xb8\xe2\x1e\x01\xd0\xe2\x1e\x01\xc8\xe2\x1e\x01\xf8\xe1\x1e\x01\xa8\
-    \xe2\x1e\x01b\x06proto3\
+    \0:\0B\x1c\xb8\xe2\x1e\x01\xd0\xe2\x1e\x01\xe0\xe2\x1e\x01\xf8\xe1\x1e\
+    \x01\xa8\xe2\x1e\x01\xc0\xe3\x1e\x01\xc8\xe2\x1e\x01b\x06proto3\
 ";
 
-static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy {
-    lock: ::protobuf::lazy::ONCE_INIT,
-    ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto,
-};
+static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
 
 fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
     ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
diff --git a/src/server.rs b/src/server.rs
index 6ea6453..56e3b5f 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -3,7 +3,6 @@ use std::ops::DerefMut;
 use std::sync::{Arc, Mutex};
 
 use env_logger::Env;
-use tokio;
 use tokio::codec::Decoder;
 use tokio::io;
 use tokio::net::TcpListener;
@@ -42,7 +41,7 @@ where
                 debug!("Return Response! {:?}", response);
                 writer.send(response)
             });
-            tokio::spawn(writes.then(|_| Ok(())))
+            tokio::spawn(writes.then(|x| x.map_err(|_| ()).map(|_| ())))
         });
 
     let mut rt = runtime::Builder::new()
diff --git a/version.txt b/version.txt
index 09ebf5d..d4d5b13 100644
--- a/version.txt
+++ b/version.txt
@@ -1,6 +1,6 @@
 	Version = TMCoreSemVer
 	// TMCoreSemVer is the current version of Tendermint Core.
-	TMCoreSemVer = "0.33.1"
+	TMCoreSemVer = "0.33.5"
 	// ABCISemVer is the semantic version of the ABCI library
-	ABCISemVer  = "0.16.1"
+	ABCISemVer  = "0.16.2"
 	ABCIVersion = ABCISemVer


Test patch: