@dashevo/dapi-grpc 0.25.6 → 0.25.9

package/src/platform/proto/org.dash.platform.dapi.v0.rs

@@ -21,11 +21,13 @@ pub struct ResponseMetadata {
     pub height: u64,
     #[prost(uint32, tag = "2")]
     pub core_chain_locked_height: u32,
-    #[prost(uint64, tag = "3")]
+    #[prost(uint32, tag = "3")]
+    pub epoch: u32,
+    #[prost(uint64, tag = "4")]
     pub time_ms: u64,
-    #[prost(uint32, tag = "4")]
+    #[prost(uint32, tag = "5")]
     pub protocol_version: u32,
-    #[prost(string, tag = "5")]
+    #[prost(string, tag = "6")]
     pub chain_id: ::prost::alloc::string::String,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -50,45 +52,136 @@ pub struct BroadcastStateTransitionResponse {}
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub id: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+    #[prost(oneof = "get_identity_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_request::Version>,
+}
+/// Nested message and enum types in `GetIdentityRequest`.
+pub mod get_identity_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityRequestV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetIdentityBalanceRequest {
+    #[prost(oneof = "get_identity_balance_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_balance_request::Version>,
+}
+/// Nested message and enum types in `GetIdentityBalanceRequest`.
+pub mod get_identity_balance_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityBalanceRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityBalanceRequestV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetIdentityBalanceAndRevisionRequest {
+    #[prost(oneof = "get_identity_balance_and_revision_request::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identity_balance_and_revision_request::Version,
+    >,
+}
+/// Nested message and enum types in `GetIdentityBalanceAndRevisionRequest`.
+pub mod get_identity_balance_and_revision_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityBalanceAndRevisionRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityBalanceAndRevisionRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identity_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_identity_response::Result>,
+    #[prost(oneof = "get_identity_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_response::Version>,
 }
 /// Nested message and enum types in `GetIdentityResponse`.
 pub mod get_identity_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_identity_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_identity_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetIdentityResponseV0`.
+    pub mod get_identity_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(bytes, tag = "1")]
+            Identity(::prost::alloc::vec::Vec<u8>),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
-        #[prost(bytes, tag = "1")]
-        Identity(::prost::alloc::vec::Vec<u8>),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentitiesRequest {
-    #[prost(bytes = "vec", repeated, tag = "1")]
-    pub ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+    #[prost(oneof = "get_identities_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identities_request::Version>,
+}
+/// Nested message and enum types in `GetIdentitiesRequest`.
+pub mod get_identities_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentitiesRequestV0 {
+        #[prost(bytes = "vec", repeated, tag = "1")]
+        pub ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentitiesRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentitiesResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identities_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_identities_response::Result>,
+    #[prost(oneof = "get_identities_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identities_response::Version>,
 }
 /// Nested message and enum types in `GetIdentitiesResponse`.
 pub mod get_identities_response {
@@ -113,60 +206,112 @@ pub mod get_identities_response {
         pub identity_entries: ::prost::alloc::vec::Vec<IdentityEntry>,
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentitiesResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_identities_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_identities_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetIdentitiesResponseV0`.
+    pub mod get_identities_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Identities(super::Identities),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Identities(Identities),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetIdentitiesResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityBalanceResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identity_balance_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_identity_balance_response::Result>,
+    #[prost(oneof = "get_identity_balance_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_balance_response::Version>,
 }
 /// Nested message and enum types in `GetIdentityBalanceResponse`.
 pub mod get_identity_balance_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityBalanceResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_identity_balance_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_identity_balance_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetIdentityBalanceResponseV0`.
+    pub mod get_identity_balance_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(uint64, tag = "1")]
+            Balance(u64),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Balance(u64),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetIdentityBalanceResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityBalanceAndRevisionResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identity_balance_and_revision_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<
-        get_identity_balance_and_revision_response::Result,
+    #[prost(oneof = "get_identity_balance_and_revision_response::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identity_balance_and_revision_response::Version,
     >,
 }
 /// Nested message and enum types in `GetIdentityBalanceAndRevisionResponse`.
 pub mod get_identity_balance_and_revision_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct BalanceAndRevision {
-        #[prost(message, optional, tag = "1")]
-        pub balance: ::core::option::Option<u64>,
-        #[prost(message, optional, tag = "2")]
-        pub revision: ::core::option::Option<u64>,
+    pub struct GetIdentityBalanceAndRevisionResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(
+            oneof = "get_identity_balance_and_revision_response_v0::Result",
+            tags = "1, 2"
+        )]
+        pub result: ::core::option::Option<
+            get_identity_balance_and_revision_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `GetIdentityBalanceAndRevisionResponseV0`.
+    pub mod get_identity_balance_and_revision_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct BalanceAndRevision {
+            #[prost(uint64, tag = "1")]
+            pub balance: u64,
+            #[prost(uint64, tag = "2")]
+            pub revision: u64,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            BalanceAndRevision(BalanceAndRevision),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        BalanceAndRevision(BalanceAndRevision),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetIdentityBalanceAndRevisionResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
@@ -256,292 +401,286 @@ pub mod security_level_map {
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityKeysRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub identity_id: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "2")]
-    pub request_type: ::core::option::Option<KeyRequestType>,
-    #[prost(message, optional, tag = "3")]
-    pub limit: ::core::option::Option<u32>,
-    #[prost(message, optional, tag = "4")]
-    pub offset: ::core::option::Option<u32>,
-    #[prost(bool, tag = "5")]
-    pub prove: bool,
+    #[prost(oneof = "get_identity_keys_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_keys_request::Version>,
+}
+/// Nested message and enum types in `GetIdentityKeysRequest`.
+pub mod get_identity_keys_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityKeysRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub identity_id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(message, optional, tag = "2")]
+        pub request_type: ::core::option::Option<super::KeyRequestType>,
+        #[prost(message, optional, tag = "3")]
+        pub limit: ::core::option::Option<u32>,
+        #[prost(message, optional, tag = "4")]
+        pub offset: ::core::option::Option<u32>,
+        #[prost(bool, tag = "5")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityKeysRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentityKeysResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identity_keys_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_identity_keys_response::Result>,
+    #[prost(oneof = "get_identity_keys_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_identity_keys_response::Version>,
 }
 /// Nested message and enum types in `GetIdentityKeysResponse`.
 pub mod get_identity_keys_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Keys {
-        #[prost(bytes = "vec", repeated, tag = "1")]
-        pub keys_bytes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+    pub struct GetIdentityKeysResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_identity_keys_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_identity_keys_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetIdentityKeysResponseV0`.
+    pub mod get_identity_keys_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct Keys {
+            #[prost(bytes = "vec", repeated, tag = "1")]
+            pub keys_bytes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Keys(Keys),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Keys(Keys),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetIdentityKeysResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetIdentitiesKeysRequest {
-    #[prost(bytes = "vec", repeated, tag = "1")]
-    pub identity_ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-    #[prost(message, optional, tag = "2")]
-    pub request_type: ::core::option::Option<KeyRequestType>,
-    #[prost(message, optional, tag = "3")]
-    pub limit: ::core::option::Option<u32>,
-    #[prost(message, optional, tag = "4")]
-    pub offset: ::core::option::Option<u32>,
-    #[prost(bool, tag = "5")]
-    pub prove: bool,
-}
-/// Nested message and enum types in `GetIdentitiesKeysRequest`.
-pub mod get_identities_keys_request {
+pub struct GetProofsRequest {
+    #[prost(oneof = "get_proofs_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_proofs_request::Version>,
+}
+/// Nested message and enum types in `GetProofsRequest`.
+pub mod get_proofs_request {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct SecurityLevelMap {
-        #[prost(
-            map = "uint32, enumeration(security_level_map::KeyKindRequestType)",
-            tag = "1"
-        )]
-        pub security_level_map: ::std::collections::HashMap<u32, i32>,
-    }
-    /// Nested message and enum types in `SecurityLevelMap`.
-    pub mod security_level_map {
-        #[derive(
-            Clone,
-            Copy,
-            Debug,
-            PartialEq,
-            Eq,
-            Hash,
-            PartialOrd,
-            Ord,
-            ::prost::Enumeration
-        )]
-        #[repr(i32)]
-        pub enum KeyKindRequestType {
-            CurrentKeyOfKindRequest = 0,
+    pub struct GetProofsRequestV0 {
+        #[prost(message, repeated, tag = "1")]
+        pub identities: ::prost::alloc::vec::Vec<get_proofs_request_v0::IdentityRequest>,
+        #[prost(message, repeated, tag = "2")]
+        pub contracts: ::prost::alloc::vec::Vec<get_proofs_request_v0::ContractRequest>,
+        #[prost(message, repeated, tag = "3")]
+        pub documents: ::prost::alloc::vec::Vec<get_proofs_request_v0::DocumentRequest>,
+    }
+    /// Nested message and enum types in `GetProofsRequestV0`.
+    pub mod get_proofs_request_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct DocumentRequest {
+            #[prost(bytes = "vec", tag = "1")]
+            pub contract_id: ::prost::alloc::vec::Vec<u8>,
+            #[prost(string, tag = "2")]
+            pub document_type: ::prost::alloc::string::String,
+            #[prost(bool, tag = "3")]
+            pub document_type_keeps_history: bool,
+            #[prost(bytes = "vec", tag = "4")]
+            pub document_id: ::prost::alloc::vec::Vec<u8>,
         }
-        impl KeyKindRequestType {
-            /// String value of the enum field names used in the ProtoBuf definition.
-            ///
-            /// The values are not transformed in any way and thus are considered stable
-            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-            pub fn as_str_name(&self) -> &'static str {
-                match self {
-                    KeyKindRequestType::CurrentKeyOfKindRequest => {
-                        "CURRENT_KEY_OF_KIND_REQUEST"
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct IdentityRequest {
+            #[prost(bytes = "vec", tag = "1")]
+            pub identity_id: ::prost::alloc::vec::Vec<u8>,
+            #[prost(enumeration = "identity_request::Type", tag = "2")]
+            pub request_type: i32,
+        }
+        /// Nested message and enum types in `IdentityRequest`.
+        pub mod identity_request {
+            #[derive(
+                Clone,
+                Copy,
+                Debug,
+                PartialEq,
+                Eq,
+                Hash,
+                PartialOrd,
+                Ord,
+                ::prost::Enumeration
+            )]
+            #[repr(i32)]
+            pub enum Type {
+                FullIdentity = 0,
+                Balance = 1,
+                Keys = 2,
+            }
+            impl Type {
+                /// String value of the enum field names used in the ProtoBuf definition.
+                ///
+                /// The values are not transformed in any way and thus are considered stable
+                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+                pub fn as_str_name(&self) -> &'static str {
+                    match self {
+                        Type::FullIdentity => "FULL_IDENTITY",
+                        Type::Balance => "BALANCE",
+                        Type::Keys => "KEYS",
                     }
                 }
-            }
-            /// Creates an enum from field names used in the ProtoBuf definition.
-            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-                match value {
-                    "CURRENT_KEY_OF_KIND_REQUEST" => Some(Self::CurrentKeyOfKindRequest),
-                    _ => None,
+                /// Creates an enum from field names used in the ProtoBuf definition.
+                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+                    match value {
+                        "FULL_IDENTITY" => Some(Self::FullIdentity),
+                        "BALANCE" => Some(Self::Balance),
+                        "KEYS" => Some(Self::Keys),
+                        _ => None,
+                    }
                 }
             }
         }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct ContractRequest {
+            #[prost(bytes = "vec", tag = "1")]
+            pub contract_id: ::prost::alloc::vec::Vec<u8>,
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetProofsRequestV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetIdentitiesKeysResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identities_keys_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_identities_keys_response::Result>,
+pub struct GetProofsResponse {
+    #[prost(oneof = "get_proofs_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_proofs_response::Version>,
 }
-/// Nested message and enum types in `GetIdentitiesKeysResponse`.
-pub mod get_identities_keys_response {
+/// Nested message and enum types in `GetProofsResponse`.
+pub mod get_proofs_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct PublicKey {
-        #[prost(bytes = "vec", tag = "1")]
-        pub value: ::prost::alloc::vec::Vec<u8>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct PublicKeyEntry {
-        #[prost(bytes = "vec", tag = "1")]
-        pub key: ::prost::alloc::vec::Vec<u8>,
+    pub struct GetProofsResponseV0 {
+        #[prost(message, optional, tag = "1")]
+        pub proof: ::core::option::Option<super::Proof>,
         #[prost(message, optional, tag = "2")]
-        pub value: ::core::option::Option<PublicKey>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct PublicKeyEntries {
-        #[prost(message, repeated, tag = "1")]
-        pub public_key_entries: ::prost::alloc::vec::Vec<PublicKeyEntry>,
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        PublicKeys(PublicKeyEntries),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetProofsResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetProofsRequest {
-    #[prost(message, repeated, tag = "1")]
-    pub identities: ::prost::alloc::vec::Vec<get_proofs_request::IdentityRequest>,
-    #[prost(message, repeated, tag = "2")]
-    pub contracts: ::prost::alloc::vec::Vec<get_proofs_request::ContractRequest>,
-    #[prost(message, repeated, tag = "3")]
-    pub documents: ::prost::alloc::vec::Vec<get_proofs_request::DocumentRequest>,
+pub struct GetDataContractRequest {
+    #[prost(oneof = "get_data_contract_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contract_request::Version>,
 }
-/// Nested message and enum types in `GetProofsRequest`.
-pub mod get_proofs_request {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DocumentRequest {
-        #[prost(bytes = "vec", tag = "1")]
-        pub contract_id: ::prost::alloc::vec::Vec<u8>,
-        #[prost(string, tag = "2")]
-        pub document_type: ::prost::alloc::string::String,
-        #[prost(bool, tag = "3")]
-        pub document_type_keeps_history: bool,
-        #[prost(bytes = "vec", tag = "4")]
-        pub document_id: ::prost::alloc::vec::Vec<u8>,
-    }
+/// Nested message and enum types in `GetDataContractRequest`.
+pub mod get_data_contract_request {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct IdentityRequest {
+    pub struct GetDataContractRequestV0 {
         #[prost(bytes = "vec", tag = "1")]
-        pub identity_id: ::prost::alloc::vec::Vec<u8>,
-        #[prost(enumeration = "identity_request::Type", tag = "2")]
-        pub request_type: i32,
-    }
-    /// Nested message and enum types in `IdentityRequest`.
-    pub mod identity_request {
-        #[derive(
-            Clone,
-            Copy,
-            Debug,
-            PartialEq,
-            Eq,
-            Hash,
-            PartialOrd,
-            Ord,
-            ::prost::Enumeration
-        )]
-        #[repr(i32)]
-        pub enum Type {
-            FullIdentity = 0,
-            Balance = 1,
-            Keys = 2,
-        }
-        impl Type {
-            /// String value of the enum field names used in the ProtoBuf definition.
-            ///
-            /// The values are not transformed in any way and thus are considered stable
-            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
-            pub fn as_str_name(&self) -> &'static str {
-                match self {
-                    Type::FullIdentity => "FULL_IDENTITY",
-                    Type::Balance => "BALANCE",
-                    Type::Keys => "KEYS",
-                }
-            }
-            /// Creates an enum from field names used in the ProtoBuf definition.
-            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-                match value {
-                    "FULL_IDENTITY" => Some(Self::FullIdentity),
-                    "BALANCE" => Some(Self::Balance),
-                    "KEYS" => Some(Self::Keys),
-                    _ => None,
-                }
-            }
-        }
+        pub id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ContractRequest {
-        #[prost(bytes = "vec", tag = "1")]
-        pub contract_id: ::prost::alloc::vec::Vec<u8>,
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetDataContractRequestV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetProofsResponse {
-    #[prost(message, optional, tag = "1")]
-    pub proof: ::core::option::Option<Proof>,
-    #[prost(message, optional, tag = "2")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetDataContractRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub id: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDataContractResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_data_contract_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_data_contract_response::Result>,
+    #[prost(oneof = "get_data_contract_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contract_response::Version>,
 }
 /// Nested message and enum types in `GetDataContractResponse`.
 pub mod get_data_contract_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetDataContractResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_data_contract_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_data_contract_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetDataContractResponseV0`.
+    pub mod get_data_contract_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(bytes, tag = "1")]
+            DataContract(::prost::alloc::vec::Vec<u8>),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
-        #[prost(bytes, tag = "1")]
-        DataContract(::prost::alloc::vec::Vec<u8>),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetDataContractResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDataContractsRequest {
-    #[prost(bytes = "vec", repeated, tag = "1")]
-    pub ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+    #[prost(oneof = "get_data_contracts_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contracts_request::Version>,
+}
+/// Nested message and enum types in `GetDataContractsRequest`.
+pub mod get_data_contracts_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetDataContractsRequestV0 {
+        #[prost(bytes = "vec", repeated, tag = "1")]
+        pub ids: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetDataContractsRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDataContractsResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_data_contracts_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_data_contracts_response::Result>,
+    #[prost(oneof = "get_data_contracts_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contracts_response::Version>,
 }
 /// Nested message and enum types in `GetDataContractsResponse`.
 pub mod get_data_contracts_response {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DataContractValue {
-        #[prost(bytes = "vec", tag = "1")]
-        pub value: ::prost::alloc::vec::Vec<u8>,
-    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
     pub struct DataContractEntry {
         #[prost(bytes = "vec", tag = "1")]
-        pub key: ::prost::alloc::vec::Vec<u8>,
+        pub identifier: ::prost::alloc::vec::Vec<u8>,
         #[prost(message, optional, tag = "2")]
-        pub value: ::core::option::Option<DataContractValue>,
+        pub data_contract: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
@@ -550,246 +689,707 @@ pub mod get_data_contracts_response {
         pub data_contract_entries: ::prost::alloc::vec::Vec<DataContractEntry>,
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetDataContractsResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_data_contracts_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_data_contracts_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetDataContractsResponseV0`.
+    pub mod get_data_contracts_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            DataContracts(super::DataContracts),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        DataContracts(DataContracts),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetDataContractsResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDataContractHistoryRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub id: ::prost::alloc::vec::Vec<u8>,
-    #[prost(message, optional, tag = "2")]
-    pub limit: ::core::option::Option<u32>,
-    #[prost(message, optional, tag = "3")]
-    pub offset: ::core::option::Option<u32>,
-    #[prost(uint64, tag = "4")]
-    pub start_at_ms: u64,
-    #[prost(bool, tag = "5")]
-    pub prove: bool,
+    #[prost(oneof = "get_data_contract_history_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contract_history_request::Version>,
+}
+/// Nested message and enum types in `GetDataContractHistoryRequest`.
+pub mod get_data_contract_history_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetDataContractHistoryRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(message, optional, tag = "2")]
+        pub limit: ::core::option::Option<u32>,
+        #[prost(message, optional, tag = "3")]
+        pub offset: ::core::option::Option<u32>,
+        #[prost(uint64, tag = "4")]
+        pub start_at_ms: u64,
+        #[prost(bool, tag = "5")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetDataContractHistoryRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDataContractHistoryResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_data_contract_history_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_data_contract_history_response::Result>,
+    #[prost(oneof = "get_data_contract_history_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_data_contract_history_response::Version>,
 }
 /// Nested message and enum types in `GetDataContractHistoryResponse`.
 pub mod get_data_contract_history_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DataContractHistoryEntry {
-        #[prost(uint64, tag = "1")]
-        pub date: u64,
-        #[prost(bytes = "vec", tag = "2")]
-        pub value: ::prost::alloc::vec::Vec<u8>,
+    pub struct GetDataContractHistoryResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_data_contract_history_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<
+            get_data_contract_history_response_v0::Result,
+        >,
     }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct DataContractHistory {
-        #[prost(message, repeated, tag = "1")]
-        pub data_contract_entries: ::prost::alloc::vec::Vec<DataContractHistoryEntry>,
+    /// Nested message and enum types in `GetDataContractHistoryResponseV0`.
+    pub mod get_data_contract_history_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct DataContractHistoryEntry {
+            #[prost(uint64, tag = "1")]
+            pub date: u64,
+            #[prost(bytes = "vec", tag = "2")]
+            pub value: ::prost::alloc::vec::Vec<u8>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct DataContractHistory {
+            #[prost(message, repeated, tag = "1")]
+            pub data_contract_entries: ::prost::alloc::vec::Vec<
+                DataContractHistoryEntry,
+            >,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            DataContractHistory(DataContractHistory),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        DataContractHistory(DataContractHistory),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetDataContractHistoryResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDocumentsRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub data_contract_id: ::prost::alloc::vec::Vec<u8>,
-    #[prost(string, tag = "2")]
-    pub document_type: ::prost::alloc::string::String,
-    #[prost(bytes = "vec", tag = "3")]
-    pub r#where: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bytes = "vec", tag = "4")]
-    pub order_by: ::prost::alloc::vec::Vec<u8>,
-    #[prost(uint32, tag = "5")]
-    pub limit: u32,
-    #[prost(bool, tag = "8")]
-    pub prove: bool,
-    #[prost(oneof = "get_documents_request::Start", tags = "6, 7")]
-    pub start: ::core::option::Option<get_documents_request::Start>,
+    #[prost(oneof = "get_documents_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_documents_request::Version>,
 }
 /// Nested message and enum types in `GetDocumentsRequest`.
 pub mod get_documents_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetDocumentsRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub data_contract_id: ::prost::alloc::vec::Vec<u8>,
+        #[prost(string, tag = "2")]
+        pub document_type: ::prost::alloc::string::String,
+        #[prost(bytes = "vec", tag = "3")]
+        pub r#where: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bytes = "vec", tag = "4")]
+        pub order_by: ::prost::alloc::vec::Vec<u8>,
+        #[prost(uint32, tag = "5")]
+        pub limit: u32,
+        #[prost(bool, tag = "8")]
+        pub prove: bool,
+        #[prost(oneof = "get_documents_request_v0::Start", tags = "6, 7")]
+        pub start: ::core::option::Option<get_documents_request_v0::Start>,
+    }
+    /// Nested message and enum types in `GetDocumentsRequestV0`.
+    pub mod get_documents_request_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Start {
+            #[prost(bytes, tag = "6")]
+            StartAfter(::prost::alloc::vec::Vec<u8>),
+            #[prost(bytes, tag = "7")]
+            StartAt(::prost::alloc::vec::Vec<u8>),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Start {
-        #[prost(bytes, tag = "6")]
-        StartAfter(::prost::alloc::vec::Vec<u8>),
-        #[prost(bytes, tag = "7")]
-        StartAt(::prost::alloc::vec::Vec<u8>),
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetDocumentsRequestV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetDocumentsResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_documents_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<get_documents_response::Result>,
+    #[prost(oneof = "get_documents_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_documents_response::Version>,
 }
 /// Nested message and enum types in `GetDocumentsResponse`.
 pub mod get_documents_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Documents {
-        #[prost(bytes = "vec", repeated, tag = "1")]
-        pub documents: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+    pub struct GetDocumentsResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_documents_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_documents_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetDocumentsResponseV0`.
+    pub mod get_documents_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct Documents {
+            #[prost(bytes = "vec", repeated, tag = "1")]
+            pub documents: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Documents(Documents),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Documents(Documents),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetDocumentsResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentitiesByPublicKeyHashesRequest {
-    #[prost(bytes = "vec", repeated, tag = "1")]
-    pub public_key_hashes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+    #[prost(oneof = "get_identities_by_public_key_hashes_request::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identities_by_public_key_hashes_request::Version,
+    >,
+}
+/// Nested message and enum types in `GetIdentitiesByPublicKeyHashesRequest`.
+pub mod get_identities_by_public_key_hashes_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentitiesByPublicKeyHashesRequestV0 {
+        #[prost(bytes = "vec", repeated, tag = "1")]
+        pub public_key_hashes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentitiesByPublicKeyHashesRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct GetIdentitiesByPublicKeyHashesResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(
-        oneof = "get_identities_by_public_key_hashes_response::Result",
-        tags = "1, 2"
-    )]
-    pub result: ::core::option::Option<
-        get_identities_by_public_key_hashes_response::Result,
+    #[prost(oneof = "get_identities_by_public_key_hashes_response::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identities_by_public_key_hashes_response::Version,
     >,
 }
 /// Nested message and enum types in `GetIdentitiesByPublicKeyHashesResponse`.
 pub mod get_identities_by_public_key_hashes_response {
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct Identities {
-        #[prost(bytes = "vec", repeated, tag = "1")]
-        pub identities: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
+    pub struct PublicKeyHashIdentityEntry {
+        #[prost(bytes = "vec", tag = "1")]
+        pub public_key_hash: ::prost::alloc::vec::Vec<u8>,
+        #[prost(message, optional, tag = "2")]
+        pub value: ::core::option::Option<::prost::alloc::vec::Vec<u8>>,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct IdentitiesByPublicKeyHashes {
+        #[prost(message, repeated, tag = "1")]
+        pub identity_entries: ::prost::alloc::vec::Vec<PublicKeyHashIdentityEntry>,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentitiesByPublicKeyHashesResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(
+            oneof = "get_identities_by_public_key_hashes_response_v0::Result",
+            tags = "1, 2"
+        )]
+        pub result: ::core::option::Option<
+            get_identities_by_public_key_hashes_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `GetIdentitiesByPublicKeyHashesResponseV0`.
+    pub mod get_identities_by_public_key_hashes_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Identities(super::IdentitiesByPublicKeyHashes),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
     }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Identities(Identities),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(GetIdentitiesByPublicKeyHashesResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetIdentityByPublicKeyHashesRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub public_key_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+pub struct GetIdentityByPublicKeyHashRequest {
+    #[prost(oneof = "get_identity_by_public_key_hash_request::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identity_by_public_key_hash_request::Version,
+    >,
+}
+/// Nested message and enum types in `GetIdentityByPublicKeyHashRequest`.
+pub mod get_identity_by_public_key_hash_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityByPublicKeyHashRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub public_key_hash: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityByPublicKeyHashRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetIdentityByPublicKeyHashesResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "get_identity_by_public_key_hashes_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<
-        get_identity_by_public_key_hashes_response::Result,
+pub struct GetIdentityByPublicKeyHashResponse {
+    #[prost(oneof = "get_identity_by_public_key_hash_response::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_identity_by_public_key_hash_response::Version,
     >,
 }
-/// Nested message and enum types in `GetIdentityByPublicKeyHashesResponse`.
-pub mod get_identity_by_public_key_hashes_response {
+/// Nested message and enum types in `GetIdentityByPublicKeyHashResponse`.
+pub mod get_identity_by_public_key_hash_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetIdentityByPublicKeyHashResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(
+            oneof = "get_identity_by_public_key_hash_response_v0::Result",
+            tags = "1, 2"
+        )]
+        pub result: ::core::option::Option<
+            get_identity_by_public_key_hash_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `GetIdentityByPublicKeyHashResponseV0`.
+    pub mod get_identity_by_public_key_hash_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(bytes, tag = "1")]
+            Identity(::prost::alloc::vec::Vec<u8>),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
-        #[prost(bytes, tag = "1")]
-        Identity(::prost::alloc::vec::Vec<u8>),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetIdentityByPublicKeyHashResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WaitForStateTransitionResultRequest {
-    #[prost(bytes = "vec", tag = "1")]
-    pub state_transition_hash: ::prost::alloc::vec::Vec<u8>,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+    #[prost(oneof = "wait_for_state_transition_result_request::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        wait_for_state_transition_result_request::Version,
+    >,
+}
+/// Nested message and enum types in `WaitForStateTransitionResultRequest`.
+pub mod wait_for_state_transition_result_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct WaitForStateTransitionResultRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub state_transition_hash: ::prost::alloc::vec::Vec<u8>,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(WaitForStateTransitionResultRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct WaitForStateTransitionResultResponse {
-    #[prost(message, optional, tag = "3")]
-    pub metadata: ::core::option::Option<ResponseMetadata>,
-    #[prost(oneof = "wait_for_state_transition_result_response::Result", tags = "1, 2")]
-    pub result: ::core::option::Option<
-        wait_for_state_transition_result_response::Result,
+    #[prost(oneof = "wait_for_state_transition_result_response::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        wait_for_state_transition_result_response::Version,
     >,
 }
 /// Nested message and enum types in `WaitForStateTransitionResultResponse`.
 pub mod wait_for_state_transition_result_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct WaitForStateTransitionResultResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(
+            oneof = "wait_for_state_transition_result_response_v0::Result",
+            tags = "1, 2"
+        )]
+        pub result: ::core::option::Option<
+            wait_for_state_transition_result_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `WaitForStateTransitionResultResponseV0`.
+    pub mod wait_for_state_transition_result_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Error(super::super::StateTransitionBroadcastError),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
     #[allow(clippy::derive_partial_eq_without_eq)]
     #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Result {
+    pub enum Version {
         #[prost(message, tag = "1")]
-        Error(super::StateTransitionBroadcastError),
-        #[prost(message, tag = "2")]
-        Proof(super::Proof),
+        V0(WaitForStateTransitionResultResponseV0),
     }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ConsensusParamsBlock {
-    #[prost(string, tag = "1")]
-    pub max_bytes: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub max_gas: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub time_iota_ms: ::prost::alloc::string::String,
+pub struct GetConsensusParamsRequest {
+    #[prost(oneof = "get_consensus_params_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_consensus_params_request::Version>,
+}
+/// Nested message and enum types in `GetConsensusParamsRequest`.
+pub mod get_consensus_params_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetConsensusParamsRequestV0 {
+        #[prost(int32, tag = "1")]
+        pub height: i32,
+        #[prost(bool, tag = "2")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetConsensusParamsRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ConsensusParamsEvidence {
-    #[prost(string, tag = "1")]
-    pub max_age_num_blocks: ::prost::alloc::string::String,
-    #[prost(string, tag = "2")]
-    pub max_age_duration: ::prost::alloc::string::String,
-    #[prost(string, tag = "3")]
-    pub max_bytes: ::prost::alloc::string::String,
+pub struct GetConsensusParamsResponse {
+    #[prost(oneof = "get_consensus_params_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_consensus_params_response::Version>,
+}
+/// Nested message and enum types in `GetConsensusParamsResponse`.
+pub mod get_consensus_params_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct ConsensusParamsBlock {
+        #[prost(string, tag = "1")]
+        pub max_bytes: ::prost::alloc::string::String,
+        #[prost(string, tag = "2")]
+        pub max_gas: ::prost::alloc::string::String,
+        #[prost(string, tag = "3")]
+        pub time_iota_ms: ::prost::alloc::string::String,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct ConsensusParamsEvidence {
+        #[prost(string, tag = "1")]
+        pub max_age_num_blocks: ::prost::alloc::string::String,
+        #[prost(string, tag = "2")]
+        pub max_age_duration: ::prost::alloc::string::String,
+        #[prost(string, tag = "3")]
+        pub max_bytes: ::prost::alloc::string::String,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetConsensusParamsResponseV0 {
+        #[prost(message, optional, tag = "1")]
+        pub block: ::core::option::Option<ConsensusParamsBlock>,
+        #[prost(message, optional, tag = "2")]
+        pub evidence: ::core::option::Option<ConsensusParamsEvidence>,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetConsensusParamsResponseV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetConsensusParamsRequest {
-    #[prost(int64, tag = "1")]
-    pub height: i64,
-    #[prost(bool, tag = "2")]
-    pub prove: bool,
+pub struct GetVersionUpgradeStateRequest {
+    #[prost(oneof = "get_version_upgrade_state_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_version_upgrade_state_request::Version>,
+}
+/// Nested message and enum types in `GetVersionUpgradeStateRequest`.
+pub mod get_version_upgrade_state_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetVersionUpgradeStateRequestV0 {
+        #[prost(bool, tag = "1")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetVersionUpgradeStateRequestV0),
+    }
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct GetConsensusParamsResponse {
-    #[prost(message, optional, tag = "1")]
-    pub block: ::core::option::Option<ConsensusParamsBlock>,
-    #[prost(message, optional, tag = "2")]
-    pub evidence: ::core::option::Option<ConsensusParamsEvidence>,
+pub struct GetVersionUpgradeStateResponse {
+    #[prost(oneof = "get_version_upgrade_state_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_version_upgrade_state_response::Version>,
+}
+/// Nested message and enum types in `GetVersionUpgradeStateResponse`.
+pub mod get_version_upgrade_state_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetVersionUpgradeStateResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_version_upgrade_state_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<
+            get_version_upgrade_state_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `GetVersionUpgradeStateResponseV0`.
+    pub mod get_version_upgrade_state_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct Versions {
+            #[prost(message, repeated, tag = "1")]
+            pub versions: ::prost::alloc::vec::Vec<VersionEntry>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct VersionEntry {
+            #[prost(uint32, tag = "1")]
+            pub version_number: u32,
+            #[prost(uint32, tag = "2")]
+            pub vote_count: u32,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Versions(Versions),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetVersionUpgradeStateResponseV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetVersionUpgradeVoteStatusRequest {
+    #[prost(oneof = "get_version_upgrade_vote_status_request::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_version_upgrade_vote_status_request::Version,
+    >,
+}
+/// Nested message and enum types in `GetVersionUpgradeVoteStatusRequest`.
+pub mod get_version_upgrade_vote_status_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetVersionUpgradeVoteStatusRequestV0 {
+        #[prost(bytes = "vec", tag = "1")]
+        pub start_pro_tx_hash: ::prost::alloc::vec::Vec<u8>,
+        #[prost(uint32, tag = "2")]
+        pub count: u32,
+        #[prost(bool, tag = "3")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetVersionUpgradeVoteStatusRequestV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetVersionUpgradeVoteStatusResponse {
+    #[prost(oneof = "get_version_upgrade_vote_status_response::Version", tags = "1")]
+    pub version: ::core::option::Option<
+        get_version_upgrade_vote_status_response::Version,
+    >,
+}
+/// Nested message and enum types in `GetVersionUpgradeVoteStatusResponse`.
+pub mod get_version_upgrade_vote_status_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetVersionUpgradeVoteStatusResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(
+            oneof = "get_version_upgrade_vote_status_response_v0::Result",
+            tags = "1, 2"
+        )]
+        pub result: ::core::option::Option<
+            get_version_upgrade_vote_status_response_v0::Result,
+        >,
+    }
+    /// Nested message and enum types in `GetVersionUpgradeVoteStatusResponseV0`.
+    pub mod get_version_upgrade_vote_status_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct VersionSignals {
+            #[prost(message, repeated, tag = "1")]
+            pub version_signals: ::prost::alloc::vec::Vec<VersionSignal>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct VersionSignal {
+            #[prost(bytes = "vec", tag = "1")]
+            pub pro_tx_hash: ::prost::alloc::vec::Vec<u8>,
+            #[prost(uint32, tag = "2")]
+            pub version: u32,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Versions(VersionSignals),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetVersionUpgradeVoteStatusResponseV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetEpochsInfoRequest {
+    #[prost(oneof = "get_epochs_info_request::Version", tags = "1")]
+    pub version: ::core::option::Option<get_epochs_info_request::Version>,
+}
+/// Nested message and enum types in `GetEpochsInfoRequest`.
+pub mod get_epochs_info_request {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetEpochsInfoRequestV0 {
+        #[prost(message, optional, tag = "1")]
+        pub start_epoch: ::core::option::Option<u32>,
+        #[prost(uint32, tag = "2")]
+        pub count: u32,
+        #[prost(bool, tag = "3")]
+        pub ascending: bool,
+        #[prost(bool, tag = "4")]
+        pub prove: bool,
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetEpochsInfoRequestV0),
+    }
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetEpochsInfoResponse {
+    #[prost(oneof = "get_epochs_info_response::Version", tags = "1")]
+    pub version: ::core::option::Option<get_epochs_info_response::Version>,
+}
+/// Nested message and enum types in `GetEpochsInfoResponse`.
+pub mod get_epochs_info_response {
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct GetEpochsInfoResponseV0 {
+        #[prost(message, optional, tag = "3")]
+        pub metadata: ::core::option::Option<super::ResponseMetadata>,
+        #[prost(oneof = "get_epochs_info_response_v0::Result", tags = "1, 2")]
+        pub result: ::core::option::Option<get_epochs_info_response_v0::Result>,
+    }
+    /// Nested message and enum types in `GetEpochsInfoResponseV0`.
+    pub mod get_epochs_info_response_v0 {
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct EpochInfos {
+            #[prost(message, repeated, tag = "1")]
+            pub epoch_infos: ::prost::alloc::vec::Vec<EpochInfo>,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Message)]
+        pub struct EpochInfo {
+            #[prost(uint32, tag = "1")]
+            pub number: u32,
+            #[prost(uint64, tag = "2")]
+            pub first_block_height: u64,
+            #[prost(uint32, tag = "3")]
+            pub first_core_block_height: u32,
+            #[prost(uint64, tag = "4")]
+            pub start_time: u64,
+            #[prost(double, tag = "5")]
+            pub fee_multiplier: f64,
+        }
+        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[derive(Clone, PartialEq, ::prost::Oneof)]
+        pub enum Result {
+            #[prost(message, tag = "1")]
+            Epochs(EpochInfos),
+            #[prost(message, tag = "2")]
+            Proof(super::super::Proof),
+        }
+    }
+    #[allow(clippy::derive_partial_eq_without_eq)]
+    #[derive(Clone, PartialEq, ::prost::Oneof)]
+    pub enum Version {
+        #[prost(message, tag = "1")]
+        V0(GetEpochsInfoResponseV0),
+    }
 }
 /// Generated client implementations.
 pub mod platform_client {
@@ -993,10 +1593,9 @@ pub mod platform_client {
                 );
             self.inner.unary(req, path, codec).await
         }
-        ///  rpc getIdentitiesKeys (GetIdentitiesKeysRequest) returns (GetIdentitiesKeysResponse);
         pub async fn get_identity_balance(
             &mut self,
-            request: impl tonic::IntoRequest<super::GetIdentityRequest>,
+            request: impl tonic::IntoRequest<super::GetIdentityBalanceRequest>,
         ) -> std::result::Result<
             tonic::Response<super::GetIdentityBalanceResponse>,
             tonic::Status,
@@ -1026,7 +1625,7 @@ pub mod platform_client {
         }
         pub async fn get_identity_balance_and_revision(
             &mut self,
-            request: impl tonic::IntoRequest<super::GetIdentityRequest>,
+            request: impl tonic::IntoRequest<super::GetIdentityBalanceAndRevisionRequest>,
         ) -> std::result::Result<
             tonic::Response<super::GetIdentityBalanceAndRevisionResponse>,
             tonic::Status,
@@ -1230,11 +1829,11 @@ pub mod platform_client {
                 );
             self.inner.unary(req, path, codec).await
         }
-        pub async fn get_identity_by_public_key_hashes(
+        pub async fn get_identity_by_public_key_hash(
             &mut self,
-            request: impl tonic::IntoRequest<super::GetIdentityByPublicKeyHashesRequest>,
+            request: impl tonic::IntoRequest<super::GetIdentityByPublicKeyHashRequest>,
         ) -> std::result::Result<
-            tonic::Response<super::GetIdentityByPublicKeyHashesResponse>,
+            tonic::Response<super::GetIdentityByPublicKeyHashResponse>,
             tonic::Status,
         > {
             self.inner
@@ -1248,14 +1847,14 @@ pub mod platform_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/org.dash.platform.dapi.v0.Platform/getIdentityByPublicKeyHashes",
+                "/org.dash.platform.dapi.v0.Platform/getIdentityByPublicKeyHash",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
                         "org.dash.platform.dapi.v0.Platform",
-                        "getIdentityByPublicKeyHashes",
+                        "getIdentityByPublicKeyHash",
                     ),
                 );
             self.inner.unary(req, path, codec).await
@@ -1320,5 +1919,95 @@ pub mod platform_client {
                 );
             self.inner.unary(req, path, codec).await
         }
+        pub async fn get_version_upgrade_state(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetVersionUpgradeStateRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetVersionUpgradeStateResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/org.dash.platform.dapi.v0.Platform/getVersionUpgradeState",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "org.dash.platform.dapi.v0.Platform",
+                        "getVersionUpgradeState",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_version_upgrade_vote_status(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetVersionUpgradeVoteStatusRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetVersionUpgradeVoteStatusResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/org.dash.platform.dapi.v0.Platform/getVersionUpgradeVoteStatus",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "org.dash.platform.dapi.v0.Platform",
+                        "getVersionUpgradeVoteStatus",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_epochs_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetEpochsInfoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetEpochsInfoResponse>,
+            tonic::Status,
+        > {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/org.dash.platform.dapi.v0.Platform/getEpochsInfo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "org.dash.platform.dapi.v0.Platform",
+                        "getEpochsInfo",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
     }
 }