feat(sdk): token and group queries

packages/dapi-grpc/build.rs

@@ -47,7 +47,7 @@ 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; 34] = [
+    const VERSIONED_REQUESTS: [&str; 40] = [
         "GetDataContractHistoryRequest",
         "GetDataContractRequest",
         "GetDataContractsRequest",
@@ -82,14 +82,20 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
         "GetIdentitiesTokenBalancesRequest",
         "GetIdentityTokenInfosRequest",
         "GetIdentitiesTokenInfosRequest",
+        "GetTokenStatusesRequest",
+        "GetTokenTotalSupplyRequest",
+        "GetGroupInfoRequest",
+        "GetGroupInfosRequest",
+        "GetGroupActionsRequest",
+        "GetGroupActionSignersRequest",
     ];
 
     // The following responses are excluded as they don't support proofs:
     // - "GetConsensusParamsResponse"
     // - "GetStatusResponse"
     //
     //  "GetEvonodesProposedEpochBlocksResponse" is used for 2 Requests
-    const VERSIONED_RESPONSES: [&str; 33] = [
+    const VERSIONED_RESPONSES: [&str; 39] = [
         "GetDataContractHistoryResponse",
         "GetDataContractResponse",
         "GetDataContractsResponse",
@@ -123,6 +129,12 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
         "GetIdentitiesTokenBalancesResponse",
         "GetIdentityTokenInfosResponse",
         "GetIdentitiesTokenInfosResponse",
+        "GetTokenStatusesResponse",
+        "GetTokenTotalSupplyResponse",
+        "GetGroupInfoResponse",
+        "GetGroupInfosResponse",
+        "GetGroupActionsResponse",
+        "GetGroupActionSignersResponse",
     ];
 
     check_unique(&VERSIONED_REQUESTS).expect("VERSIONED_REQUESTS");

packages/rs-dapi-client/src/transport/grpc.rs

@@ -514,3 +514,93 @@ impl_transport_request_grpc!(
     RequestSettings::default(),
     get_status
 );
+
+// rpc getIdentityTokenBalances(GetIdentityTokenBalancesRequest) returns (GetIdentityTokenBalancesResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetIdentityTokenBalancesRequest,
+    platform_proto::GetIdentityTokenBalancesResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_identity_token_balances
+);
+
+// rpc getIdentitiesTokenBalances(GetIdentitiesTokenBalancesRequest) returns (GetIdentitiesTokenBalancesResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetIdentitiesTokenBalancesRequest,
+    platform_proto::GetIdentitiesTokenBalancesResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_identities_token_balances
+);
+
+// rpc getIdentityTokenInfos(GetIdentityTokenInfosRequest) returns (GetIdentityTokenInfosResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetIdentityTokenInfosRequest,
+    platform_proto::GetIdentityTokenInfosResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_identity_token_infos
+);
+
+// rpc getIdentitiesTokenInfos(GetIdentitiesTokenInfosRequest) returns (GetIdentitiesTokenInfosResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetIdentitiesTokenInfosRequest,
+    platform_proto::GetIdentitiesTokenInfosResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_identities_token_infos
+);
+
+// rpc getTokenStatuses(GetTokenStatusesRequest) returns (GetTokenStatusesResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetTokenStatusesRequest,
+    platform_proto::GetTokenStatusesResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_token_statuses
+);
+
+// rpc getTokenTotalSupply(GetTokenTotalSupplyRequest) returns (GetTokenTotalSupplyResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetTokenTotalSupplyRequest,
+    platform_proto::GetTokenTotalSupplyResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_token_total_supply
+);
+
+// rpc getGroupInfo(GetGroupInfoRequest) returns (GetGroupInfoResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetGroupInfoRequest,
+    platform_proto::GetGroupInfoResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_group_info
+);
+
+// rpc getGroupInfos(GetGroupInfosRequest) returns (GetGroupInfosResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetGroupInfosRequest,
+    platform_proto::GetGroupInfosResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_group_infos
+);
+
+// rpc getGroupActions(GetGroupActionsRequest) returns (GetGroupActionsResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetGroupActionsRequest,
+    platform_proto::GetGroupActionsResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_group_actions
+);
+
+// rpc getGroupActionSigners(GetGroupActionSignersRequest) returns (GetGroupActionSignersResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetGroupActionSignersRequest,
+    platform_proto::GetGroupActionSignersResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_group_action_signers
+);

packages/rs-dpp/src/balances/total_single_token_balance/mod.rs

@@ -1,9 +1,14 @@
 use crate::balances::credits::SignedTokenAmount;
 use crate::ProtocolError;
+#[cfg(feature = "fixtures-and-mocks")]
+use bincode::Encode;
+#[cfg(feature = "fixtures-and-mocks")]
+use platform_serialization::de::Decode;
 use std::fmt;
 
 /// A structure where the token supply and the aggregated token account balances should always be equal
 #[derive(Copy, Clone, Debug)]
+#[cfg_attr(feature = "fixtures-and-mocks", derive(Encode, Decode))]
 pub struct TotalSingleTokenBalance {
     /// the token supply
     pub token_supply: SignedTokenAmount,

packages/rs-dpp/src/tokens/info/mod.rs

@@ -6,6 +6,8 @@ use platform_serialization::de::Decode;
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 use platform_version::version::PlatformVersion;
 use platform_versioning::PlatformVersioned;
+#[cfg(feature = "fixtures-and-mocks")]
+use serde::{Deserialize, Serialize};
 
 mod methods;
 pub mod v0;
@@ -22,6 +24,7 @@ pub mod v0;
     PartialEq,
 )]
 #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
+#[cfg_attr(feature = "fixtures-and-mocks", derive(Serialize, Deserialize))]
 pub enum IdentityTokenInfo {
     V0(IdentityTokenInfoV0),
 }

packages/rs-dpp/src/tokens/info/v0/mod.rs

@@ -1,7 +1,10 @@
 use bincode::{Decode, Encode};
 use derive_more::From;
+#[cfg(feature = "fixtures-and-mocks")]
+use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Encode, Decode, From, PartialEq)]
+#[cfg_attr(feature = "fixtures-and-mocks", derive(Serialize, Deserialize))]
 /// Token information for an identity (version 0).
 pub struct IdentityTokenInfoV0 {
     pub frozen: bool,

packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/mod.rs

@@ -7,6 +7,7 @@ use dpp::version::PlatformVersion;
 use drive::grovedb::TransactionArg;
 
 mod common;
+mod test;
 pub mod v0;
 pub mod v1;
 
@@ -42,6 +43,11 @@ impl<C> Platform<C> {
                 known_versions: vec![0, 1],
                 received: version,
             })),
-        }
+        }?;
+
+        // UNCOMMENT ONLY TO GENERATE SDK TEST DATA
+        // self.create_sdk_test_data(&block_info, transaction, platform_version)?;
+
+        Ok(())
     }
 }

packages/rs-drive-abci/src/execution/platform_events/initialization/create_genesis_state/test/mod.rs

@@ -0,0 +1,33 @@
+use crate::error::execution::ExecutionError;
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use dpp::block::block_info::BlockInfo;
+use dpp::dashcore::Network;
+use dpp::version::PlatformVersion;
+use drive::grovedb::TransactionArg;
+
+mod tokens;
+
+impl<C> Platform<C> {
+    /// Creates testing data for SDK functional and e2e tests
+    ///
+    /// This is function must be used only for testing
+    /// purposes on local networks and DISABLED BY DEFAULT
+    #[allow(dead_code)]
+    pub(super) fn create_sdk_test_data(
+        &self,
+        block_info: &BlockInfo,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<(), Error> {
+        if self.config.network != Network::Regtest {
+            return Err(Error::Execution(ExecutionError::CorruptedCodeExecution(
+                "create_sdk_test_data must be called only on local network",
+            )));
+        }
+
+        self.create_data_for_group_token_queries(block_info, transaction, platform_version)?;
+
+        Ok(())
+    }
+}