feat(sdk): get identities by non-unique public key hashes

packages/dapi-grpc/build.rs

@@ -63,7 +63,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; 40] = [
+    const VERSIONED_REQUESTS: [&str; 41] = [
         "GetDataContractHistoryRequest",
         "GetDataContractRequest",
         "GetDataContractsRequest",
@@ -75,6 +75,7 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
         "GetIdentityContractNonceRequest",
         "GetIdentityBalanceAndRevisionRequest",
         "GetIdentityBalanceRequest",
+        "GetIdentityByNonUniquePublicKeyHashRequest",
         "GetIdentityByPublicKeyHashRequest",
         "GetIdentityKeysRequest",
         "GetIdentityRequest",
@@ -110,6 +111,9 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
     // - "GetConsensusParamsResponse"
     // - "GetStatusResponse"
     //
+    // The following responses are excluded as they need custom proof handling:
+    // - "GetIdentityByNonUniquePublicKeyHashResponse"
+    //
     //  "GetEvonodesProposedEpochBlocksResponse" is used for 2 Requests
     const VERSIONED_RESPONSES: [&str; 39] = [
         "GetDataContractHistoryResponse",

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

@@ -33,6 +33,8 @@ service Platform {
   rpc getDocuments(GetDocumentsRequest) returns (GetDocumentsResponse);
   rpc getIdentityByPublicKeyHash(GetIdentityByPublicKeyHashRequest)
       returns (GetIdentityByPublicKeyHashResponse);
+  rpc getIdentityByNonUniquePublicKeyHash(GetIdentityByNonUniquePublicKeyHashRequest)
+      returns (GetIdentityByNonUniquePublicKeyHashResponse);
   rpc waitForStateTransitionResult(WaitForStateTransitionResultRequest)
       returns (WaitForStateTransitionResultResponse);
   rpc getConsensusParams(GetConsensusParamsRequest)
@@ -620,6 +622,35 @@ message GetIdentityByPublicKeyHashResponse {
   oneof version { GetIdentityByPublicKeyHashResponseV0 v0 = 1; }
 }
 
+message GetIdentityByNonUniquePublicKeyHashRequest {
+  message GetIdentityByNonUniquePublicKeyHashRequestV0 {
+    bytes public_key_hash = 1;
+    optional bytes start_after = 2; // Give one result after a previous result
+    bool prove = 3;
+  }
+  oneof version { GetIdentityByNonUniquePublicKeyHashRequestV0 v0 = 1; }
+}
+
+message GetIdentityByNonUniquePublicKeyHashResponse {
+  message GetIdentityByNonUniquePublicKeyHashResponseV0 {
+    message IdentityResponse {
+      optional bytes identity = 1;
+    }
+
+    message IdentityProvedResponse {
+      Proof grovedb_identity_public_key_hash_proof = 1;
+      optional bytes identity_proof_bytes = 2; // A hack, we return 2 proofs
+    }
+    oneof result {
+      IdentityResponse identity = 1;
+      IdentityProvedResponse proof = 2;
+    }
+
+    ResponseMetadata metadata = 3;  // Metadata about the blockchain state
+  }
+  oneof version { GetIdentityByNonUniquePublicKeyHashResponseV0 v0 = 1; }
+}
+
 message WaitForStateTransitionResultRequest {
   message WaitForStateTransitionResultRequestV0 {
     bytes state_transition_hash = 1;  // The hash of the state transition to wait for

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

@@ -490,6 +490,15 @@ impl_transport_request_grpc!(
     get_status
 );
 
+//   rpc getIdentityByNonUniquePublicKeyHash(GetIdentityByNonUniquePublicKeyHashRequest) returns (GetIdentityByNonUniquePublicKeyHashResponse);
+impl_transport_request_grpc!(
+    platform_proto::GetIdentityByNonUniquePublicKeyHashRequest,
+    platform_proto::GetIdentityByNonUniquePublicKeyHashResponse,
+    PlatformGrpcClient,
+    RequestSettings::default(),
+    get_identity_by_non_unique_public_key_hash
+);
+
 // rpc getIdentityTokenBalances(GetIdentityTokenBalancesRequest) returns (GetIdentityTokenBalancesResponse);
 impl_transport_request_grpc!(
     platform_proto::GetIdentityTokenBalancesRequest,

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

@@ -1,8 +1,6 @@
-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::data_contract::associated_token::token_configuration::v0::TokenConfigurationV0;
 use dpp::data_contract::associated_token::token_configuration_convention::v0::TokenConfigurationConventionV0;
 use dpp::data_contract::associated_token::token_distribution_rules::v0::TokenDistributionRulesV0;
@@ -110,14 +108,20 @@ impl<C> Platform<C> {
         transaction: TransactionArg,
         platform_version: &PlatformVersion,
     ) -> Result<(), Error> {
+        let mut rng = StdRng::seed_from_u64(0u64);
+        let non_unique_key =
+            IdentityPublicKey::random_voting_key_with_rng(11, &mut rng, platform_version)?;
+
         for id in [IDENTITY_ID_1, IDENTITY_ID_2, IDENTITY_ID_3] {
             // Create identity without keys
             let mut identity = Identity::create_basic_identity(id, platform_version)?;
 
             // Generate keys
             let seed = id.to_buffer()[0];
             let mut rng = StdRng::seed_from_u64(seed as u64);
-            let keys = IdentityPublicKey::main_keys_with_random_authentication_keys_with_private_keys_with_rng(3, &mut rng, platform_version)?;
+            let mut keys = IdentityPublicKey::main_keys_with_random_authentication_keys_with_private_keys_with_rng(3, &mut rng, platform_version)?;
+            // every identity has the same non-unique key
+            keys.push(non_unique_key.clone());
 
             for (key, private_key) in keys.iter() {
                 let private_key = hex::encode(private_key);

packages/rs-drive-abci/src/query/identity_based_queries/identity_by_non_unique_public_key_hash/mod.rs

@@ -0,0 +1,70 @@
+use crate::error::query::QueryError;
+use crate::error::Error;
+use crate::platform_types::platform::Platform;
+use crate::platform_types::platform_state::PlatformState;
+use crate::query::QueryValidationResult;
+use dapi_grpc::platform::v0::get_identity_by_non_unique_public_key_hash_request::Version as RequestVersion;
+use dapi_grpc::platform::v0::get_identity_by_non_unique_public_key_hash_response::Version as ResponseVersion;
+use dapi_grpc::platform::v0::{
+    GetIdentityByNonUniquePublicKeyHashRequest, GetIdentityByNonUniquePublicKeyHashResponse,
+};
+use dpp::version::PlatformVersion;
+
+mod v0;
+
+impl<C> Platform<C> {
+    /// Querying of an identity by a public key hash
+    pub fn query_identity_by_non_unique_public_key_hash(
+        &self,
+        GetIdentityByNonUniquePublicKeyHashRequest { version }: GetIdentityByNonUniquePublicKeyHashRequest,
+        platform_state: &PlatformState,
+        platform_version: &PlatformVersion,
+    ) -> Result<QueryValidationResult<GetIdentityByNonUniquePublicKeyHashResponse>, Error> {
+        let Some(version) = version else {
+            return Ok(QueryValidationResult::new_with_error(
+                QueryError::DecodingError(
+                    "could not decode identity by public key non unique hash query".to_string(),
+                ),
+            ));
+        };
+        // TODO why `identity_by_unique_public_key_hash`?
+        // Shouldn't we rename or add new field like `identity_by_non_unique_public_key_hash`?
+        let feature_version_bounds = &platform_version
+            .drive_abci
+            .query
+            .identity_based_queries
+            .identity_by_unique_public_key_hash;
+
+        let feature_version = match &version {
+            RequestVersion::V0(_) => 0,
+        };
+
+        if !feature_version_bounds.check_version(feature_version) {
+            return Ok(QueryValidationResult::new_with_error(
+                QueryError::UnsupportedQueryVersion(
+                    "identity_by_non_unique_public_key_hash".to_string(),
+                    feature_version_bounds.min_version,
+                    feature_version_bounds.max_version,
+                    platform_version.protocol_version,
+                    feature_version,
+                ),
+            ));
+        }
+
+        match version {
+            RequestVersion::V0(request_v0) => {
+                let request = self.query_identity_by_non_unique_public_key_hash_v0(
+                    request_v0,
+                    platform_state,
+                    platform_version,
+                )?;
+
+                Ok(
+                    request.map(|response_v0| GetIdentityByNonUniquePublicKeyHashResponse {
+                        version: Some(ResponseVersion::V0(response_v0)),
+                    }),
+                )
+            }
+        }
+    }
+}