feat: rs-sdk: rust software development kit for Dash Platform

Cargo.toml

@@ -17,5 +17,8 @@ members = [
     "packages/feature-flags-contract",
     "packages/dpns-contract",
     "packages/data-contracts",
+    "packages/rs-drive-proof-verifier",
     "packages/wasm-dpp",
+    "packages/rs-dapi-client",
+    "packages/rs-sdk",
 ]

packages/dapi-grpc/Cargo.toml

@@ -19,15 +19,19 @@ tonic = { version = "0.9.2", features = [
     "codegen",
     "prost",
 ], default-features = false }
-
+serde = { version = "1.0.171", optional = true, features = ["derive"] }
+base64 = { version = "0.21.0", optional = true }
+hex = { version = "0.4.3", optional = true }
+tenderdash-proto = { git = "https://github.com/dashpay/rs-tenderdash-abci" }
 [build-dependencies]
 tonic-build = { version = "0.9.2" }
 
 [features]
-default = ["core", "platform", "client"]
+default = ["core", "platform", "client", "serde"]
 core = ["core_v0"]
 platform = ["platform_v0"]
 client = ["tonic/channel", "tonic/tls", "tonic/tls-roots", "platform"]
+serde = ["dep:serde", "dep:base64", "dep:hex"]
 
 core_v0 = []
 platform_v0 = []

packages/dapi-grpc/build.rs

@@ -1,63 +1,142 @@
 use std::{
-    collections::HashMap,
     fs::{create_dir_all, remove_dir_all},
     path::PathBuf,
 };
 
+use tonic_build::Builder;
+
 fn main() {
     generate().expect("failed to compile protobuf definitions");
 
     println!("cargo:rerun-if-changed=./protos");
+    println!("cargo:rerun-if-env-changed=CARGO_FEATURE_SERDE");
 }
 
+struct MappingConfig {
+    protobuf_file: PathBuf,
+    out_dir: PathBuf,
+    builder: Builder,
+    proto_includes: Vec<PathBuf>,
+}
 /// 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(
+    let core = MappingConfig::new(
         PathBuf::from("protos/core/v0/core.proto"),
         PathBuf::from("src/core/proto"),
     );
-    input.insert(
+    core.generate().unwrap();
+
+    let platform = MappingConfig::new(
         PathBuf::from("protos/platform/v0/platform.proto"),
         PathBuf::from("src/platform/proto"),
     );
 
-    let proto_includes = vec![abs_path(&PathBuf::from("protos"))];
+    #[cfg(feature = "serde")]
+    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 = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "identity_id",
+            r#"#[serde(with = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "ids",
+            r#"#[serde(with = "crate::deserialization::vec_base64string")]"#,
+        )
+        .field_attribute(
+            "ResponseMetadata.height",
+            r#"#[serde(with = "crate::deserialization::from_to_string")]"#,
+        )
+        .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 = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "public_key_hashes",
+            r#"#[serde(with = "crate::deserialization::vec_base64string")]"#,
+        )
+        // Proof fields
+        .field_attribute(
+            "Proof.grovedb_proof",
+            r#"#[serde(with = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "Proof.quorum_hash",
+            r#"#[serde(with = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "Proof.signature",
+            r#"#[serde(with = "crate::deserialization::base64string")]"#,
+        )
+        .field_attribute(
+            "Proof.block_id_hash",
+            r#"#[serde(with = "crate::deserialization::base64string")]"#,
+        );
 
-    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)?;
+    platform.generate().unwrap();
+
+    Ok(())
+}
+
+impl MappingConfig {
+    fn new(protobuf_file: PathBuf, out_dir: PathBuf) -> Self {
+        let protobuf_file = abs_path(&protobuf_file);
+        let out_dir = abs_path(&out_dir);
+
+        let builder = tonic_build::configure()
+            .build_server(false)
+            .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 = pb.build_client(false).build_transport(false);
+
+        Self {
+            protobuf_file,
+            out_dir,
+            builder,
+            proto_includes: vec![abs_path(&PathBuf::from("protos"))],
         }
-        create_dir_all(&dest)?;
+    }
 
-        generate1(&[proto], &proto_includes, &dest)?;
+    fn type_attribute(mut self, path: &str, attribute: &str) -> Self {
+        self.builder = self.builder.type_attribute(path, attribute);
+        self
     }
 
-    Ok(())
-}
+    fn field_attribute(mut self, path: &str, attribute: &str) -> Self {
+        self.builder = self.builder.field_attribute(path, attribute);
+        self
+    }
 
-/// 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)
+    /// Run single generation process.
+    fn generate(self) -> Result<(), std::io::Error> {
+        // Remove old compiled files; ignore errors
+        if self.out_dir.exists() {
+            remove_dir_all(&self.out_dir)?;
+        }
+        create_dir_all(&self.out_dir)?;
+
+        self.builder
+            .compile(&[self.protobuf_file], &self.proto_includes)
+    }
 }
 
 fn abs_path(path: &PathBuf) -> PathBuf {

packages/dapi-grpc/protos/platform/v0/platform.proto

@@ -220,6 +220,7 @@ message GetProofsRequest {
 
   message ContractRequest {
     bytes contract_id = 1;
+    bool is_historical = 2;
   }
 
   repeated IdentityRequest identities = 1;

packages/dapi-grpc/src/deserialization.rs

@@ -0,0 +1,34 @@
+pub use tenderdash_proto::serializers::bytes::{
+    base64string, hexstring, option_base64string, vec_base64string,
+};
+
+/// Serialize using [ToString] and deserialize using [FromStr] trait implementations.
+pub mod from_to_string {
+    use std::{fmt::Display, str::FromStr};
+
+    use serde::{Deserialize, Serializer};
+
+    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
+    where
+        D: serde::de::Deserializer<'de>,
+        T: FromStr,
+        T::Err: Display,
+    {
+        use serde::de::Error;
+
+        String::deserialize(deserializer).and_then(|string| {
+            string
+                .parse::<T>()
+                .map_err(|err| Error::custom(err.to_string()))
+        })
+    }
+
+    /// Serialize from T into string
+    pub fn serialize<S, T>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+        T: ToString,
+    {
+        serializer.serialize_str(&value.to_string())
+    }
+}

packages/dapi-grpc/src/lib.rs

@@ -13,3 +13,7 @@ pub mod platform {
         include!("platform/proto/org.dash.platform.dapi.v0.rs");
     }
 }
+
+#[cfg(feature = "serde")]
+// Serde deserialization logic
+pub mod deserialization;