@dashevo/dapi-grpc 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "dapi-grpc"
+description = "GRPC client for Dash Platform"
+version = "0.25.0"
+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>",
+]
+edition = "2021"
+rust-version = "1.73"
+license = "MIT"
+
+[dependencies]
+prost = { version = "0.11.9" }
+prost-types = { version = "0.11.9" }
+tonic = { version = "0.9.2", features = [
+    "codegen",
+    "prost",
+], default-features = false }
+
+[build-dependencies]
+tonic-build = { version = "0.9.2" }
+
+[features]
+default = ["core", "platform", "client"]
+core = ["core_v0"]
+platform = ["platform_v0"]
+client = ["tonic/channel", "tonic/tls", "tonic/tls-roots", "platform"]
+
+core_v0 = []
+platform_v0 = []
+
+[lib]
+
+[[example]]
+name = "core_example"
+path = "clients/core/v0/rust/core_example.rs"
+
+
+[[example]]
+name = "platform_example"
+path = "clients/platform/v0/rust/platform_example.rs"

package/build.rs

@@ -0,0 +1,69 @@
+use std::{
+    collections::HashMap,
+    fs::{create_dir_all, remove_dir_all},
+    path::PathBuf,
+};
+
+fn main() {
+    generate().expect("failed to compile protobuf definitions");
+
+    println!("cargo:rerun-if-changed=./protos");
+}
+
+/// Generate Rust definitions from Protobuf definitions
+pub fn generate() -> Result<(), std::io::Error> {
+    // Mapping between protobuf files => output directory
+    let mut input = HashMap::<PathBuf, PathBuf>::new();
+    input.insert(
+        PathBuf::from("protos/core/v0/core.proto"),
+        PathBuf::from("src/core/proto"),
+    );
+    input.insert(
+        PathBuf::from("protos/platform/v0/platform.proto"),
+        PathBuf::from("src/platform/proto"),
+    );
+
+    let proto_includes = vec![abs_path(&PathBuf::from("protos"))];
+
+    for (proto, dest) in input {
+        let proto = abs_path(&proto);
+        let dest = abs_path(&dest);
+        // Remove old compiled files; ignore errors
+        if dest.exists() {
+            remove_dir_all(&dest)?;
+        }
+        create_dir_all(&dest)?;
+
+        generate1(&[proto], &proto_includes, &dest)?;
+    }
+
+    Ok(())
+}
+
+/// Run single generation process.
+///
+/// All paths must be absolute
+fn generate1(
+    files: &[PathBuf],
+    proto_includes: &[PathBuf],
+    out_dir: &PathBuf,
+) -> Result<(), std::io::Error> {
+    let pb = tonic_build::configure()
+        .build_server(false)
+        .out_dir(out_dir)
+        .protoc_arg("--experimental_allow_proto3_optional");
+    #[cfg(feature = "client")]
+    let pb = pb.build_client(true).build_transport(true);
+    #[cfg(not(feature = "client"))]
+    let pb = pb.build_client(false).build_transport(false);
+
+    pb.compile(files, proto_includes)
+}
+
+fn abs_path(path: &PathBuf) -> PathBuf {
+    if path.is_absolute() {
+        return path.to_owned();
+    }
+
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(path)
+}

package/clients/core/v0/rust/README.md

@@ -0,0 +1,3 @@
+# Rust bindings
+
+Rust definitions can be found in [dapi-grpc/src](../../../../src/) directory.

package/clients/core/v0/rust/core_example.rs

@@ -0,0 +1,14 @@
+use dapi_grpc::core::v0 as core;
+use prost::Message;
+
+fn main() {
+    let request = core::GetBlockRequest {
+        block: Some(core::get_block_request::Block::Height(123)),
+    };
+    let mut buffer = Vec::<u8>::new();
+    request.encode(&mut buffer).expect("failed to encode data");
+
+    let decoded = core::GetBlockRequest::decode(buffer.as_ref()).expect("failed to decode data");
+
+    assert_eq!(request, decoded);
+}

package/clients/platform/v0/nodejs/PlatformPromiseClient.js

@@ -30,6 +30,8 @@ const {
             GetIdentityResponse: PBJSGetIdentityResponse,
             GetDataContractRequest: PBJSGetDataContractRequest,
             GetDataContractResponse: PBJSGetDataContractResponse,
+            GetDataContractHistoryRequest: PBJSGetDataContractHistoryRequest,
+            GetDataContractHistoryResponse: PBJSGetDataContractHistoryResponse,
             GetDocumentsRequest: PBJSGetDocumentsRequest,
             GetDocumentsResponse: PBJSGetDocumentsResponse,
             GetIdentitiesByPublicKeyHashesRequest: PBJSGetIdentitiesByPublicKeyHashesRequest,
@@ -38,6 +40,14 @@ const {
             WaitForStateTransitionResultResponse: PBJSWaitForStateTransitionResultResponse,
             GetConsensusParamsRequest: PBJSGetConsensusParamsRequest,
             GetConsensusParamsResponse: PBJSGetConsensusParamsResponse,
+            GetEpochsInfoRequest: PBJSGetEpochsInfoRequest,
+            GetEpochsInfoResponse: PBJSGetEpochsInfoResponse,
+            GetProtocolVersionUpgradeVoteStatusRequest:
+              PBJSGetProtocolVersionUpgradeVoteStatusRequest,
+            GetProtocolVersionUpgradeVoteStatusResponse:
+              PBJSGetProtocolVersionUpgradeVoteStatusResponse,
+            GetProtocolVersionUpgradeStateRequest: PBJSGetProtocolVersionUpgradeStateRequest,
+            GetProtocolVersionUpgradeStateResponse: PBJSGetProtocolVersionUpgradeStateResponse,
           },
         },
       },
@@ -49,10 +59,14 @@ const {
   BroadcastStateTransitionResponse: ProtocBroadcastStateTransitionResponse,
   GetIdentityResponse: ProtocGetIdentityResponse,
   GetDataContractResponse: ProtocGetDataContractResponse,
+  GetDataContractHistoryResponse: ProtocGetDataContractHistoryResponse,
   GetDocumentsResponse: ProtocGetDocumentsResponse,
   GetIdentitiesByPublicKeyHashesResponse: ProtocGetIdentitiesByPublicKeyHashesResponse,
   WaitForStateTransitionResultResponse: ProtocWaitForStateTransitionResultResponse,
   GetConsensusParamsResponse: ProtocGetConsensusParamsResponse,
+  GetEpochsInfoResponse: ProtocGetEpochsInfoResponse,
+  GetProtocolVersionUpgradeVoteStatusResponse: ProtocGetProtocolVersionUpgradeVoteStatusResponse,
+  GetProtocolVersionUpgradeStateResponse: ProtocGetProtocolVersionUpgradeStateResponse,
 } = require('./platform_protoc');
 
 const getPlatformDefinition = require('../../../../lib/getPlatformDefinition');
@@ -91,6 +105,10 @@ class PlatformPromiseClient {
       this.client.getDataContract.bind(this.client),
     );
 
+    this.client.getDataContractHistory = promisify(
+      this.client.getDataContractHistory.bind(this.client),
+    );
+
     this.client.getDocuments = promisify(
       this.client.getDocuments.bind(this.client),
     );
@@ -107,6 +125,18 @@ class PlatformPromiseClient {
       this.client.getConsensusParams.bind(this.client),
     );
 
+    this.client.getEpochsInfo = promisify(
+      this.client.getEpochsInfo.bind(this.client),
+    );
+
+    this.client.getProtocolVersionUpgradeVoteStatus = promisify(
+      this.client.getProtocolVersionUpgradeVoteStatus.bind(this.client),
+    );
+
+    this.client.getProtocolVersionUpgradeState = promisify(
+      this.client.getProtocolVersionUpgradeState.bind(this.client),
+    );
+
     this.protocolVersion = undefined;
   }
 
@@ -204,6 +234,38 @@ class PlatformPromiseClient {
     );
   }
 
+  /**
+   *
+   * @param {!GetDataContractHistoryRequest} getDataContractHistoryRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @returns {Promise<!GetDataContractResponse>}
+   */
+  getDataContractHistory(getDataContractHistoryRequest, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getDataContractHistory(
+      getDataContractHistoryRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetDataContractHistoryResponse,
+              PBJSGetDataContractHistoryResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetDataContractHistoryRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
   /**
    *
    * @param {!GetDocumentsRequest} getDocumentsRequest
@@ -335,6 +397,107 @@ class PlatformPromiseClient {
     );
   }
 
+  /**
+   * @param {!GetEpochsInfoRequest} getEpochsInfoRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetEpochsInfoResponse>}
+   */
+  getEpochsInfo(getEpochsInfoRequest, metadata = {}, options = {}) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getEpochsInfo(
+      getEpochsInfoRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetEpochsInfoResponse,
+              PBJSGetEpochsInfoResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetEpochsInfoRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  /**
+   * @param {!GetProtocolVersionUpgradeVoteStatusRequest} getProtocolVersionUpgradeVoteStatusRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetProtocolVersionUpgradeVoteStatusResponse>}
+   */
+  getProtocolVersionUpgradeVoteStatus(
+    getProtocolVersionUpgradeVoteStatusRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getProtocolVersionUpgradeVoteStatus(
+      getProtocolVersionUpgradeVoteStatusRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetProtocolVersionUpgradeVoteStatusResponse,
+              PBJSGetProtocolVersionUpgradeVoteStatusResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetProtocolVersionUpgradeVoteStatusRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
+  /**
+   * @param {!GetProtocolVersionUpgradeStateRequest} getProtocolVersionUpgradeStateRequest
+   * @param {?Object<string, string>} metadata
+   * @param {CallOptions} [options={}]
+   * @return {Promise<!GetProtocolVersionUpgradeStateResponse>}
+   */
+  getProtocolVersionUpgradeState(
+    getProtocolVersionUpgradeStateRequest,
+    metadata = {},
+    options = {},
+  ) {
+    if (!isObject(metadata)) {
+      throw new Error('metadata must be an object');
+    }
+
+    return this.client.getProtocolVersionUpgradeState(
+      getProtocolVersionUpgradeStateRequest,
+      convertObjectToMetadata(metadata),
+      {
+        interceptors: [
+          jsonToProtobufInterceptorFactory(
+            jsonToProtobufFactory(
+              ProtocGetProtocolVersionUpgradeStateResponse,
+              PBJSGetProtocolVersionUpgradeStateResponse,
+            ),
+            protobufToJsonFactory(
+              PBJSGetProtocolVersionUpgradeStateRequest,
+            ),
+          ),
+        ],
+        ...options,
+      },
+    );
+  }
+
   /**
    * @param {string} protocolVersion
    */