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

packages/dapi-grpc/build.rs

@@ -73,7 +73,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",
@@ -85,6 +85,7 @@ fn configure_platform(mut platform: MappingConfig) -> MappingConfig {
         "GetIdentityContractNonceRequest",
         "GetIdentityBalanceAndRevisionRequest",
         "GetIdentityBalanceRequest",
+        "GetIdentityByNonUniquePublicKeyHashRequest",
         "GetIdentityByPublicKeyHashRequest",
         "GetIdentityKeysRequest",
         "GetIdentityRequest",
@@ -120,6 +121,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

@@ -37,6 +37,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)
@@ -592,6 +594,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 =

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-dpp/src/state_transition/state_transitions/document/batch_transition/methods/mod.rs

@@ -32,6 +32,7 @@ use crate::state_transition::StateTransition;
 use crate::tokens::emergency_action::TokenEmergencyAction;
 #[cfg(feature = "state-transition-signing")]
 use crate::tokens::token_payment_info::TokenPaymentInfo;
+#[cfg(feature = "state-transition-signing")]
 use crate::tokens::token_pricing_schedule::TokenPricingSchedule;
 #[cfg(feature = "state-transition-signing")]
 use crate::tokens::{PrivateEncryptedNote, SharedEncryptedNote};

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/methods/v1/mod.rs

@@ -19,6 +19,7 @@ use crate::state_transition::batch_transition::accessors::DocumentsBatchTransiti
 use crate::state_transition::StateTransition;
 #[cfg(feature = "state-transition-signing")]
 use crate::tokens::emergency_action::TokenEmergencyAction;
+#[cfg(feature = "state-transition-signing")]
 use crate::tokens::token_pricing_schedule::TokenPricingSchedule;
 #[cfg(feature = "state-transition-signing")]
 use crate::tokens::{PrivateEncryptedNote, SharedEncryptedNote};

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/v1/v1_methods.rs

@@ -1,21 +1,27 @@
+#[cfg(feature = "state-transition-signing")]
 use crate::fee::Credits;
 #[cfg(feature = "state-transition-signing")]
 use crate::identity::signer::Signer;
 #[cfg(feature = "state-transition-signing")]
 use crate::identity::SecurityLevel;
+#[cfg(feature = "state-transition-signing")]
 use crate::prelude::IdentityNonce;
 #[cfg(feature = "state-transition-signing")]
 use crate::prelude::IdentityPublicKey;
 #[cfg(feature = "state-transition-signing")]
 use crate::prelude::UserFeeIncrease;
+#[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::batched_transition::BatchedTransition;
-use crate::state_transition::batch_transition::{BatchTransitionV1, TokenDirectPurchaseTransition, TokenSetPriceForDirectPurchaseTransition};
+use crate::state_transition::batch_transition::BatchTransitionV1;
+#[cfg(feature = "state-transition-signing")]
+use crate::state_transition::batch_transition::{TokenDirectPurchaseTransition, TokenSetPriceForDirectPurchaseTransition};
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::{TokenClaimTransition, TokenBurnTransition, TokenConfigUpdateTransition, TokenDestroyFrozenFundsTransition, TokenEmergencyActionTransition, TokenFreezeTransition, TokenMintTransition, TokenTransferTransition, TokenUnfreezeTransition};
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::BatchTransition;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::StateTransition;
+#[cfg(feature = "state-transition-signing")]
 use crate::ProtocolError;
 #[cfg(feature = "state-transition-signing")]
 use platform_value::Identifier;
@@ -48,13 +54,15 @@ use crate::state_transition::batch_transition::token_claim_transition::TokenClai
 use crate::state_transition::batch_transition::token_config_update_transition::TokenConfigUpdateTransitionV0;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_destroy_frozen_funds_transition::TokenDestroyFrozenFundsTransitionV0;
+#[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_direct_purchase_transition::TokenDirectPurchaseTransitionV0;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_emergency_action_transition::TokenEmergencyActionTransitionV0;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_freeze_transition::TokenFreezeTransitionV0;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_mint_transition::TokenMintTransitionV0;
+#[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_set_price_for_direct_purchase_transition::TokenSetPriceForDirectPurchaseTransitionV0;
 #[cfg(feature = "state-transition-signing")]
 use crate::state_transition::batch_transition::token_transfer_transition::TokenTransferTransitionV0;
@@ -64,6 +72,7 @@ use crate::state_transition::batch_transition::token_unfreeze_transition::TokenU
 use crate::tokens::emergency_action::TokenEmergencyAction;
 #[cfg(feature = "state-transition-signing")]
 use crate::tokens::{PrivateEncryptedNote, SharedEncryptedNote};
+#[cfg(feature = "state-transition-signing")]
 use crate::tokens::token_pricing_schedule::TokenPricingSchedule;
 
 impl DocumentsBatchTransitionMethodsV1 for BatchTransitionV1 {

packages/rs-drive-abci/Cargo.toml

@@ -103,10 +103,10 @@ assert_matches = "1.5.0"
 drive-abci = { path = ".", features = ["testing-config", "mocks"] }
 bls-signatures = { git = "https://github.com/dashpay/bls-signatures", tag = "1.3.3" }
 mockall = { version = "0.13" }
+
 # For tests of grovedb verify
 rocksdb = { version = "0.23.0" }
 integer-encoding = { version = "4.0.0" }
-serial_test = { version = "3.2.0" }
 
 [features]
 default = []

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

@@ -153,14 +153,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,69 @@
+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(),
+                ),
+            ));
+        };
+
+        let feature_version_bounds = &platform_version
+            .drive_abci
+            .query
+            .identity_based_queries
+            .identity_by_non_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)),
+                    }),
+                )
+            }
+        }
+    }
+}