@dashevo/dapi-grpc 0.25.22 → 1.0.0-beta.1

package/Cargo.toml

@@ -1,36 +1,50 @@
 [package]
 name = "dapi-grpc"
 description = "GRPC client for Dash Platform"
-version = "0.25.22"
+version = "1.0.0-beta.1"
 authors = [
-    "Samuel Westrich <sam@dash.org>",
-    "Igor Markin <igor.markin@dash.org>",
-    "Łukasz Klimek <lukasz.klimek@dash.org>",
-    "Anton Suprunchuk <anton.suprunchuk@dash.org>",
-    "Ivan Shumkov <shumkov@dash.org>",
+  "Samuel Westrich <sam@dash.org>",
+  "Igor Markin <igor.markin@dash.org>",
+  "Łukasz Klimek <lukasz.klimek@dash.org>",
+  "Anton Suprunchuk <anton.suprunchuk@dash.org>",
+  "Ivan Shumkov <shumkov@dash.org>",
 ]
 edition = "2021"
-rust-version = "1.73"
+rust-version = "1.76"
 license = "MIT"
 
 [features]
-default = ["core", "platform", "client", "serde"]
+default = ["core", "platform", "client"]
 core = []
 platform = []
 # Re-export Dash Platform protobuf types as `dapi_grpc::platform::proto`
+# Note: client needs tls and tls-roots to connect to testnet which uses TLS.
 tenderdash-proto = []
-client = ["tonic/channel", "tonic/tls", "tonic/tls-roots", "platform"]
+client = [
+  "tonic/channel",
+  "tonic/transport",
+  "tonic/tls",
+  "tonic/tls-roots",
+  "tonic/tls-webpki-roots",
+  "platform",
+]
+server = ["tonic/channel", "tonic/transport", "platform"]
 serde = ["dep:serde", "dep:serde_bytes"]
+mocks = ["serde", "dep:serde_json"]
 
 [dependencies]
-prost = { version = "0.11.9" }
-tonic = { version = "0.9.2", features = [
-    "codegen",
-    "prost",
+prost = { version = "0.12.3" }
+futures-core = "0.3.30"
+tonic = { version = "0.11", features = [
+  "codegen",
+  "prost",
 ], default-features = false }
-serde = { version = "1.0.171", optional = true, features = ["derive"] }
+serde = { version = "1.0.197", optional = true, features = ["derive"] }
 serde_bytes = { version = "0.11.12", optional = true }
-tenderdash-proto = { git = "https://github.com/dashpay/rs-tenderdash-abci" }
+serde_json = { version = "1.0", optional = true }
+tenderdash-proto = { git = "https://github.com/dashpay/rs-tenderdash-abci", version = "1.0.0", tag = "v1.0.0", default-features = false, features = [
+  "grpc",
+] }
 dapi-grpc-macros = { path = "../rs-dapi-grpc-macros" }
 platform-version = { path = "../rs-platform-version" }
 
@@ -49,4 +63,9 @@ name = "platform_example"
 path = "clients/platform/v0/rust/platform_example.rs"
 
 [package.metadata.cargo-machete]
-ignored = ["platform-version", "serde_bytes"]
+ignored = [
+  "platform-version",
+  "serde_bytes",
+  "futures-core",
+  "dapi-grpc-macros",
+]

package/build.rs

@@ -1,12 +1,36 @@
 use std::{
+    collections::HashSet,
     fs::{create_dir_all, remove_dir_all},
     path::PathBuf,
+    process::exit,
 };
 
 use tonic_build::Builder;
 
+const SERDE_WITH_BYTES: &str = r#"#[cfg_attr(feature = "serde", serde(with = "serde_bytes"))]"#;
+const SERDE_WITH_BASE64: &str =
+    r#"#[cfg_attr(feature = "serde", serde(with = "crate::deserialization::vec_base64string"))]"#;
+const SERDE_WITH_STRING: &str =
+    r#"#[cfg_attr(feature = "serde", serde(with = "crate::deserialization::from_to_string"))]"#;
+
 fn main() {
-    generate().expect("failed to compile protobuf definitions");
+    let core = MappingConfig::new(
+        PathBuf::from("protos/core/v0/core.proto"),
+        PathBuf::from("src/core"),
+    );
+
+    configure_core(core)
+        .generate()
+        .expect("generate core proto");
+
+    let platform = MappingConfig::new(
+        PathBuf::from("protos/platform/v0/platform.proto"),
+        PathBuf::from("src/platform"),
+    );
+
+    configure_platform(platform)
+        .generate()
+        .expect("generate platform proto");
 
     println!("cargo:rerun-if-changed=./protos");
     println!("cargo:rerun-if-env-changed=CARGO_FEATURE_SERDE");
@@ -18,29 +42,20 @@ struct MappingConfig {
     builder: Builder,
     proto_includes: Vec<PathBuf>,
 }
-/// Generate Rust definitions from Protobuf definitions
-pub fn generate() -> Result<(), std::io::Error> {
-    let core = MappingConfig::new(
-        PathBuf::from("protos/core/v0/core.proto"),
-        PathBuf::from("src/core/proto"),
-    );
-    core.generate().unwrap();
-
-    let mut platform = MappingConfig::new(
-        PathBuf::from("protos/platform/v0/platform.proto"),
-        PathBuf::from("src/platform/proto"),
-    );
 
+fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
     // Derive features for versioned messages
     //
     // "GetConsensusParamsRequest" is excluded as this message does not support proofs
-    const VERSIONED_REQUESTS: [&str; 15] = [
+    const VERSIONED_REQUESTS: [&str; 25] = [
         "GetDataContractHistoryRequest",
         "GetDataContractRequest",
         "GetDataContractsRequest",
         "GetDocumentsRequest",
         "GetIdentitiesByPublicKeyHashesRequest",
         "GetIdentitiesRequest",
+        "GetIdentityNonceRequest",
+        "GetIdentityContractNonceRequest",
         "GetIdentityBalanceAndRevisionRequest",
         "GetIdentityBalanceRequest",
         "GetIdentityByPublicKeyHashRequest",
@@ -50,10 +65,18 @@ pub fn generate() -> Result<(), std::io::Error> {
         "WaitForStateTransitionResultRequest",
         "GetProtocolVersionUpgradeStateRequest",
         "GetProtocolVersionUpgradeVoteStatusRequest",
+        "GetPathElementsRequest",
+        "GetIdentitiesContractKeysRequest",
+        "GetPrefundedSpecializedBalanceRequest",
+        "GetContestedResourcesRequest",
+        "GetContestedResourceVoteStateRequest",
+        "GetContestedResourceVotersForIdentityRequest",
+        "GetContestedResourceIdentityVotesRequest",
+        "GetVotePollsByEndDateRequest",
     ];
 
     //  "GetConsensusParamsResponse" is excluded as this message does not support proofs
-    const VERSIONED_RESPONSES: [&str; 16] = [
+    const VERSIONED_RESPONSES: [&str; 26] = [
         "GetDataContractHistoryResponse",
         "GetDataContractResponse",
         "GetDataContractsResponse",
@@ -62,6 +85,8 @@ pub fn generate() -> Result<(), std::io::Error> {
         "GetIdentitiesResponse",
         "GetIdentityBalanceAndRevisionResponse",
         "GetIdentityBalanceResponse",
+        "GetIdentityNonceResponse",
+        "GetIdentityContractNonceResponse",
         "GetIdentityByPublicKeyHashResponse",
         "GetIdentityKeysResponse",
         "GetIdentityResponse",
@@ -70,8 +95,19 @@ pub fn generate() -> Result<(), std::io::Error> {
         "GetEpochsInfoResponse",
         "GetProtocolVersionUpgradeStateResponse",
         "GetProtocolVersionUpgradeVoteStatusResponse",
+        "GetPathElementsResponse",
+        "GetIdentitiesContractKeysResponse",
+        "GetPrefundedSpecializedBalanceResponse",
+        "GetContestedResourcesResponse",
+        "GetContestedResourceVoteStateResponse",
+        "GetContestedResourceVotersForIdentityResponse",
+        "GetContestedResourceIdentityVotesResponse",
+        "GetVotePollsByEndDateResponse",
     ];
 
+    check_unique(&VERSIONED_REQUESTS).expect("VERSIONED_REQUESTS");
+    check_unique(&VERSIONED_RESPONSES).expect("VERSIONED_RESPONSES");
+
     // Derive VersionedGrpcMessage on requests
     for msg in VERSIONED_REQUESTS {
         platform = platform
@@ -92,66 +128,113 @@ pub fn generate() -> Result<(), std::io::Error> {
             .message_attribute(msg, r#"#[grpc_versions(0)]"#);
     }
 
-    #[cfg(feature = "serde")]
+    // All messages can be mocked.
+    let platform = platform.message_attribute(".", r#"#[derive( ::dapi_grpc_macros::Mockable)]"#);
+
     let platform = platform
         .type_attribute(
             ".",
-            r#"#[derive(::serde::Serialize, ::serde::Deserialize)]"#,
-        )
-        .type_attribute(".", r#"#[serde(rename_all = "snake_case")]"#)
-        .field_attribute("id", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("identity_id", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute(
-            "ids",
-            r#"#[serde(with = "crate::deserialization::vec_base64string")]"#,
-        )
-        .field_attribute(
-            "ResponseMetadata.height",
-            r#"#[serde(with = "crate::deserialization::from_to_string")]"#,
+            r#"#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]"#,
         )
-        .field_attribute(
-            "ResponseMetadata.time_ms",
-            r#"#[serde(with = "crate::deserialization::from_to_string")]"#,
-        )
-        .field_attribute(
-            "start_at_ms",
-            r#"#[serde(with = "crate::deserialization::from_to_string")]"#,
-        )
-        .field_attribute("public_key_hash", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute(
-            "public_key_hashes",
-            r#"#[serde(with = "crate::deserialization::vec_base64string")]"#,
+        .type_attribute(
+            ".",
+            r#"#[cfg_attr(feature = "serde", serde(rename_all = "snake_case"))]"#,
         )
+        .field_attribute("id", SERDE_WITH_BYTES)
+        .field_attribute("identity_id", SERDE_WITH_BYTES)
+        .field_attribute("ids", SERDE_WITH_BASE64)
+        .field_attribute("ResponseMetadata.height", SERDE_WITH_STRING)
+        .field_attribute("ResponseMetadata.time_ms", SERDE_WITH_STRING)
+        .field_attribute("start_at_ms", SERDE_WITH_STRING)
+        .field_attribute("public_key_hash", SERDE_WITH_BYTES)
+        .field_attribute("public_key_hashes", SERDE_WITH_BASE64)
         // Get documents fields
-        .field_attribute("data_contract_id", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("where", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("order_by", r#"#[serde(with = "serde_bytes")]"#)
+        .field_attribute("data_contract_id", SERDE_WITH_BYTES)
+        .field_attribute("where", SERDE_WITH_BYTES)
+        .field_attribute("order_by", SERDE_WITH_BYTES)
         // Proof fields
-        .field_attribute("Proof.grovedb_proof", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("Proof.quorum_hash", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("Proof.signature", r#"#[serde(with = "serde_bytes")]"#)
-        .field_attribute("Proof.block_id_hash", r#"#[serde(with = "serde_bytes")]"#);
+        .field_attribute("Proof.grovedb_proof", SERDE_WITH_BYTES)
+        .field_attribute("Proof.quorum_hash", SERDE_WITH_BYTES)
+        .field_attribute("Proof.signature", SERDE_WITH_BYTES)
+        .field_attribute("Proof.block_id_hash", SERDE_WITH_BYTES);
+
+    #[allow(clippy::let_and_return)]
+    platform
+}
 
-    platform.generate().unwrap();
+/// Check for duplicate messages in the list.
+fn check_unique(messages: &[&'static str]) -> Result<(), String> {
+    let mut hashset: HashSet<&'static str> = HashSet::new();
+    let mut duplicates = String::new();
 
-    Ok(())
+    for value in messages {
+        if !hashset.insert(*value) {
+            duplicates.push_str(value);
+            duplicates.push_str(", ");
+        }
+    }
+
+    if duplicates.is_empty() {
+        Ok(())
+    } else {
+        Err(format!(
+            "Duplicate messages found: {}",
+            duplicates.trim_end_matches(", ")
+        ))
+    }
+}
+
+fn configure_core(core: MappingConfig) -> MappingConfig {
+    // All messages can be mocked.
+    let core = core.message_attribute(".", r#"#[derive(::dapi_grpc_macros::Mockable)]"#);
+
+    // Serde support
+    let core = core.type_attribute(
+        ".",
+        r#"#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]"#,
+    );
+
+    #[allow(clippy::let_and_return)]
+    core
 }
 
 impl MappingConfig {
+    /// Create a new MappingConfig instance.
+    ///
+    /// ## Arguments
+    ///
+    /// * `protobuf_file` - Path to the protobuf file to use as input.
+    /// * `out_dir` - Output directory where subdirectories for generated files will be created.
+    /// Depending on the features, either `client`, `server` or `client_server` subdirectory
+    /// will be created inside `out_dir`.
     fn new(protobuf_file: PathBuf, out_dir: PathBuf) -> Self {
         let protobuf_file = abs_path(&protobuf_file);
-        let out_dir = abs_path(&out_dir);
+
+        let build_server = cfg!(feature = "server");
+        let build_client = cfg!(feature = "client");
+
+        // Depending on the features, we need to build the server, client or both.
+        // We save these artifacts in separate directories to avoid overwriting the generated files
+        // when another crate requires different features.
+        let out_dir_suffix = match (build_server, build_client) {
+            (true, true) => "client_server",
+            (true, false) => "server",
+            (false, true) => "client",
+            (false, false) => {
+                println!("WARNING: At least one of the features 'server' or 'client' must be enabled; dapi-grpc will not generate any files.");
+                exit(0)
+            }
+        };
+
+        let out_dir = abs_path(&out_dir.join(out_dir_suffix));
 
         let builder = tonic_build::configure()
-            .build_server(false)
+            .build_server(build_server)
+            .build_client(build_client)
+            .build_transport(build_server || build_client)
             .out_dir(out_dir.clone())
             .protoc_arg("--experimental_allow_proto3_optional");
 
-        #[cfg(feature = "client")]
-        let builder = builder.build_client(true).build_transport(true);
-        #[cfg(not(feature = "client"))]
-        let builder = builder.build_client(false).build_transport(false);
-
         Self {
             protobuf_file,
             out_dir,

package/clients/core/v0/nodejs/CorePromiseClient.js

@@ -24,10 +24,14 @@ const {
       platform: {
         dapi: {
           v0: {
-            GetStatusRequest: PBJSGetStatusRequest,
-            GetStatusResponse: PBJSGetStatusResponse,
+            GetBlockchainStatusRequest: PBJSGetBlockchainStatusRequest,
+            GetBlockchainStatusResponse: PBJSGetBlockchainStatusResponse,
+            GetMasternodeStatusRequest: PBJSGetMasternodeStatusRequest,
+            GetMasternodeStatusResponse: PBJSGetMasternodeStatusResponse,
             GetBlockRequest: PBJSGetBlockRequest,
             GetBlockResponse: PBJSGetBlockResponse,
+            GetBestBlockHeightRequest: PBJSGetBestBlockHeightRequest,
+            GetBestBlockHeightResponse: PBJSGetBestBlockHeightResponse,
             BroadcastTransactionRequest: PBJSBroadcastTransactionRequest,
             BroadcastTransactionResponse: PBJSBroadcastTransactionResponse,
             GetTransactionRequest: PBJSGetTransactionRequest,
@@ -38,6 +42,8 @@ const {
             GetEstimatedTransactionFeeResponse: PBJSGetEstimatedTransactionFeeResponse,
             TransactionsWithProofsRequest: PBJSTransactionsWithProofsRequest,
             TransactionsWithProofsResponse: PBJSTransactionsWithProofsResponse,
+            MasternodeListRequest: PBJSMasternodeListRequest,
+            MasternodeListResponse: PBJSMasternodeListResponse,
           },
         },
       },
@@ -46,13 +52,16 @@ const {
 } = require('./core_pbjs');
 
 const {
-  GetStatusResponse: ProtocGetStatusResponse,
+  GetBlockchainStatusResponse: ProtocGetBlockchainStatusResponse,
+  GetMasternodeStatusResponse: ProtocGetMasternodeStatusResponse,
   GetBlockResponse: ProtocGetBlockResponse,
+  GetBestBlockHeightResponse: ProtocGetBestBlockHeightResponse,
   BroadcastTransactionResponse: ProtocBroadcastTransactionResponse,
   GetTransactionResponse: ProtocGetTransactionResponse,
   BlockHeadersWithChainLocksResponse: ProtocBlockHeadersWithChainLocksResponse,
   GetEstimatedTransactionFeeResponse: ProtocGetEstimatedTransactionFeeResponse,
   TransactionsWithProofsResponse: ProtocTransactionsWithProofsResponse,
+  MasternodeListResponse: ProtocMasternodeListResponse,
 } = require('./core_protoc');
 
 const getCoreDefinition = require('../../../../lib/getCoreDefinition');
@@ -79,14 +88,22 @@ class CorePromiseClient {
 
     this.client = new CoreNodeJSClient(strippedHostname, credentials, options);
 
-    this.client.getStatus = promisify(
-      this.client.getStatus.bind(this.client),
+    this.client.getBlockchainStatus = promisify(
+      this.client.getBlockchainStatus.bind(this.client),
+    );
+
+    this.client.getMasternodeStatus = promisify(
+      this.client.getMasternodeStatus.bind(this.client),
     );
 
     this.client.getBlock = promisify(
       this.client.getBlock.bind(this.client),
     );
 
+    this.client.getBestBlockHeight = promisify(
+      this.client.getBestBlockHeight.bind(this.client),
+    );
+
     this.client.broadcastTransaction = promisify(
       this.client.broadcastTransaction.bind(this.client),
     );
@@ -101,28 +118,28 @@ class CorePromiseClient {
   }
 
   /**
-   * @param {!GetStatusRequest} getStatusRequest
+   * @param {!GetBlockchainStatusRequest} getBlockchainStatusRequest
    * @param {?Object<string, string>} metadata
    * @param {CallOptions} [options={}]
-   * @return {Promise<!GetStatusResponse>}
+   * @return {Promise<!GetBlockchainStatusResponse>}
    */
-  getStatus(getStatusRequest, metadata = {}, options = {}) {
+  getBlockchainStatus(getBlockchainStatusRequest, metadata = {}, options = {}) {
     if (!isObject(metadata)) {
       throw new Error('metadata must be an object');
     }
 
-    return this.client.getStatus(
-      getStatusRequest,
+    return this.client.getBlockchainStatus(
+      getBlockchainStatusRequest,
       convertObjectToMetadata(metadata),
       {
         interceptors: [
           jsonToProtobufInterceptorFactory(
             jsonToProtobufFactory(
-              ProtocGetStatusResponse,
-              PBJSGetStatusResponse,
+              ProtocGetBlockchainStatusResponse,
+              PBJSGetBlockchainStatusResponse,
             ),
             protobufToJsonFactory(
-              PBJSGetStatusRequest,
+              PBJSGetBlockchainStatusRequest,
             ),
           ),
         ],
@@ -162,6 +179,68 @@ class CorePromiseClient {
     );
   }
 
+  /**
+   * @param {!GetBestBlockHeightRequest} getBestBlockHeightRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetBestBlockHeightResponse>}
+   */
+  getBestBlockHeight(getBestBlockHeightRequest, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getBestBlockHeight(
+      getBestBlockHeightRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetBestBlockHeightResponse,
+              PBJSGetBestBlockHeightResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetBestBlockHeightRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  /**
+   * @param {!GetMasternodeStatusRequest} getMasternodeStatusRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetMasternodeStatusResponse>}
+   */
+  getMasternodeStatus(getMasternodeStatusRequest, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getMasternodeStatus(
+      getMasternodeStatusRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetMasternodeStatusResponse,
+              PBJSGetMasternodeStatusResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetMasternodeStatusRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
   /**
    * @param {!BroadcastTransactionRequest} broadcastTransactionRequest
    * @param {?Object<string, string>} metadata
@@ -322,6 +401,38 @@ class CorePromiseClient {
       },
     );
   }
+
+  /**
+   * @param {MasternodeListRequest} masternodeListRequest The request proto
+   * @param {?Object<string, string>} metadata User defined call metadata
+   * @param {CallOptions} [options={}]
+   * @return {!grpc.web.ClientReadableStream<!MasternodeListResponse>|undefined}
+   *     The XHR Node Readable Stream
+   */
+  subscribeToMasternodeList(masternodeListRequest, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.subscribeToMasternodeList(
+      masternodeListRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocMasternodeListResponse,
+              PBJSMasternodeListResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSMasternodeListRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
 }
 
 module.exports = CorePromiseClient;