feat: get proofs for tokens

Author: QuantumExplorer

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

@@ -446,10 +446,27 @@ message GetProofsRequest {
       oneof request_type { ContestedResourceVoteStatusRequest contested_resource_vote_status_request = 1; }
     }
 
+    message IdentityTokenBalanceRequest {
+      bytes token_id = 1;
+      bytes identity_id = 2;
+    }
+
+    message IdentityTokenInfoRequest {
+      bytes token_id = 1;
+      bytes identity_id = 2;
+    }
+
+    message TokenStatusRequest {
+      bytes token_id = 1;
+    }
+
     repeated IdentityRequest identities = 1;  // List of identity requests
     repeated ContractRequest contracts = 2;   // List of contract requests
     repeated DocumentRequest documents = 3;   // List of document requests
     repeated VoteStatusRequest votes = 4;
+    repeated IdentityTokenBalanceRequest identity_token_balances = 5;
+    repeated IdentityTokenInfoRequest identity_token_infos = 6;
+    repeated TokenStatusRequest token_statuses = 7;
   }
 
   oneof version { GetProofsRequestV0 v0 = 1; }

packages/rs-dpp/src/state_transition/state_transitions/document/batch_transition/batched_transition/token_mint_transition/v0_methods.rs

@@ -1,7 +1,6 @@
 use platform_value::Identifier;
 use crate::balances::credits::TokenAmount;
 use crate::data_contract::associated_token::token_configuration::TokenConfiguration;
-use crate::data_contract::associated_token::token_configuration::v0::TokenConfigurationV0;
 use crate::prelude::IdentityNonce;
 use crate::ProtocolError;
 use crate::state_transition::batch_transition::batched_transition::multi_party_action::AllowedAsMultiPartyAction;

packages/rs-drive-abci/src/query/proofs/v0/mod.rs

@@ -4,6 +4,9 @@ use crate::platform_types::platform::Platform;
 use crate::platform_types::platform_state::PlatformState;
 use crate::query::QueryValidationResult;
 use dapi_grpc::platform::v0::get_proofs_request::get_proofs_request_v0::vote_status_request::RequestType;
+use dapi_grpc::platform::v0::get_proofs_request::get_proofs_request_v0::{
+    IdentityTokenBalanceRequest, IdentityTokenInfoRequest, TokenStatusRequest,
+};
 use dapi_grpc::platform::v0::get_proofs_request::GetProofsRequestV0;
 use dapi_grpc::platform::v0::get_proofs_response::{get_proofs_response_v0, GetProofsResponseV0};
 use dpp::check_validation_result_with_data;
@@ -13,6 +16,9 @@ use dpp::validation::ValidationResult;
 use dpp::version::PlatformVersion;
 use dpp::voting::vote_polls::contested_document_resource_vote_poll::ContestedDocumentResourceVotePoll;
 use drive::drive::identity::{IdentityDriveQuery, IdentityProveRequestType};
+use drive::query::identity_token_balance_drive_query::IdentityTokenBalanceDriveQuery;
+use drive::query::identity_token_info_drive_query::IdentityTokenInfoDriveQuery;
+use drive::query::token_status_drive_query::TokenStatusDriveQuery;
 use drive::query::{IdentityBasedVoteDriveQuery, SingleDocumentDriveQuery};
 
 impl<C> Platform<C> {
@@ -23,6 +29,9 @@ impl<C> Platform<C> {
             contracts,
             documents,
             votes,
+            identity_token_balances,
+            identity_token_infos,
+            token_statuses,
         }: GetProofsRequestV0,
         platform_state: &PlatformState,
         platform_version: &PlatformVersion,
@@ -145,11 +154,72 @@ impl<C> Platform<C> {
             })
             .collect::<Result<Vec<IdentityBasedVoteDriveQuery>, QueryError>>());
 
+        let token_balance_queries = check_validation_result_with_data!(identity_token_balances
+            .into_iter()
+            .map(|identity_token_balance_request| {
+                let IdentityTokenBalanceRequest {
+                    token_id,
+                    identity_id,
+                } = identity_token_balance_request;
+                Ok(IdentityTokenBalanceDriveQuery {
+                    identity_id: Identifier::try_from(identity_id).map_err(|_| {
+                        QueryError::InvalidArgument(
+                            "identity_id must be a valid identifier (32 bytes long)".to_string(),
+                        )
+                    })?,
+                    token_id: Identifier::try_from(token_id).map_err(|_| {
+                        QueryError::InvalidArgument(
+                            "token_id must be a valid identifier (32 bytes long)".to_string(),
+                        )
+                    })?,
+                })
+            })
+            .collect::<Result<Vec<IdentityTokenBalanceDriveQuery>, QueryError>>());
+
+        let token_info_queries = check_validation_result_with_data!(identity_token_infos
+            .into_iter()
+            .map(|identity_token_info_request| {
+                let IdentityTokenInfoRequest {
+                    token_id,
+                    identity_id,
+                } = identity_token_info_request;
+                Ok(IdentityTokenInfoDriveQuery {
+                    identity_id: Identifier::try_from(identity_id).map_err(|_| {
+                        QueryError::InvalidArgument(
+                            "identity_id must be a valid identifier (32 bytes long)".to_string(),
+                        )
+                    })?,
+                    token_id: Identifier::try_from(token_id).map_err(|_| {
+                        QueryError::InvalidArgument(
+                            "token_id must be a valid identifier (32 bytes long)".to_string(),
+                        )
+                    })?,
+                })
+            })
+            .collect::<Result<Vec<IdentityTokenInfoDriveQuery>, QueryError>>());
+
+        let token_status_queries = check_validation_result_with_data!(token_statuses
+            .into_iter()
+            .map(|token_status_request| {
+                let TokenStatusRequest { token_id } = token_status_request;
+                Ok(TokenStatusDriveQuery {
+                    token_id: Identifier::try_from(token_id).map_err(|_| {
+                        QueryError::InvalidArgument(
+                            "token_id must be a valid identifier (32 bytes long)".to_string(),
+                        )
+                    })?,
+                })
+            })
+            .collect::<Result<Vec<TokenStatusDriveQuery>, QueryError>>());
+
         let proof = self.drive.prove_multiple_state_transition_results(
             &identity_requests,
             &contract_ids,
             &document_queries,
             &vote_queries,
+            &token_balance_queries,
+            &token_info_queries,
+            &token_status_queries,
             None,
             platform_version,
         )?;
@@ -190,6 +260,9 @@ mod tests {
             contracts: vec![],
             documents: vec![],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let result = platform
@@ -213,6 +286,9 @@ mod tests {
             contracts: vec![],
             documents: vec![],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let result = platform
@@ -239,6 +315,9 @@ mod tests {
             }],
             documents: vec![],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let result = platform
@@ -263,6 +342,9 @@ mod tests {
                 document_contested_status: 0,
             }],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let result = platform
@@ -287,6 +369,9 @@ mod tests {
                 document_contested_status: 0,
             }],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let result = platform
@@ -311,6 +396,9 @@ mod tests {
                 document_contested_status: 0,
             }],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let validation_result = platform
@@ -363,6 +451,9 @@ mod tests {
                     },
                 )),
             }],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let validation_result = platform
@@ -395,6 +486,9 @@ mod tests {
                 document_contested_status: 0,
             }],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         let validation_result = platform

packages/rs-drive-abci/tests/strategy_tests/token_tests.rs

@@ -12,7 +12,6 @@ mod tests {
     use dpp::state_transition::StateTransition;
     use dpp::tests::json_document::json_document_to_created_contract;
     use dpp::tokens::token_event::TokenEvent;
-    use drive::query::PathQuery;
     use drive_abci::config::{
         ChainLockConfig, ExecutionConfig, InstantLockConfig, PlatformConfig, PlatformTestConfig,
         ValidatorSetConfig,
@@ -68,7 +67,7 @@ mod tests {
             .collect();
 
         let contract = created_contract.data_contract_mut();
-        let mut token_configuration = contract
+        let token_configuration = contract
             .token_configuration_mut(0)
             .expect("expected to get token configuration");
         token_configuration.set_minting_allow_choosing_destination(true);
@@ -216,7 +215,7 @@ mod tests {
             .collect();
 
         let contract = created_contract.data_contract_mut();
-        let mut token_configuration = contract
+        let token_configuration = contract
             .token_configuration_mut(0)
             .expect("expected to get token configuration");
         token_configuration.set_minting_allow_choosing_destination(true);

packages/rs-drive-abci/tests/strategy_tests/verify_state_transitions.rs

@@ -113,6 +113,9 @@ pub(crate) fn verify_state_transitions_were_or_were_not_executed(
             contracts: vec![],
             documents: vec![],
             votes: vec![],
+            identity_token_balances: vec![],
+            identity_token_infos: vec![],
+            token_statuses: vec![],
         };
 
         if let Some(action) = action {

packages/rs-drive/src/prove/prove_multiple_state_transition_results/mod.rs

@@ -4,6 +4,9 @@ use crate::error::drive::DriveError;
 use crate::error::Error;
 use crate::query::{IdentityBasedVoteDriveQuery, SingleDocumentDriveQuery};
 
+use crate::query::identity_token_balance_drive_query::IdentityTokenBalanceDriveQuery;
+use crate::query::identity_token_info_drive_query::IdentityTokenInfoDriveQuery;
+use crate::query::token_status_drive_query::TokenStatusDriveQuery;
 use dpp::version::PlatformVersion;
 use grovedb::TransactionArg;
 
@@ -21,6 +24,14 @@ impl Drive {
     ///   if the contract is historical.
     /// - `document_queries`: A list of [SingleDocumentDriveQuery]. These specify the documents
     ///   to be proven.
+    /// - `vote_queries`: A list of [IdentityBasedVoteDriveQuery]. These would be to figure out the
+    ///   result of votes based on identities making them.
+    /// - `token_balance_queries`: A slice of [IdentityTokenBalanceDriveQuery] objects specifying
+    ///   token balance queries for identities.
+    /// - `token_info_queries`: A slice of [IdentityTokenInfoDriveQuery] objects specifying
+    ///   token information queries for identities.
+    /// - `token_status_queries`: A slice of [TokenStatusDriveQuery] objects specifying token
+    ///   status queries.
     /// - `transaction`: An optional grovedb transaction
     /// - `drive_version`: A reference to the [DriveVersion] object that specifies the version of
     ///   the function to call.
@@ -34,6 +45,9 @@ impl Drive {
         contract_ids: &[([u8; 32], Option<bool>)], //bool represents if it is historical
         document_queries: &[SingleDocumentDriveQuery],
         vote_queries: &[IdentityBasedVoteDriveQuery],
+        token_balance_queries: &[IdentityTokenBalanceDriveQuery],
+        token_info_queries: &[IdentityTokenInfoDriveQuery],
+        token_status_queries: &[TokenStatusDriveQuery],
         transaction: TransactionArg,
         platform_version: &PlatformVersion,
     ) -> Result<Vec<u8>, Error> {
@@ -48,6 +62,9 @@ impl Drive {
                 contract_ids,
                 document_queries,
                 vote_queries,
+                token_balance_queries,
+                token_info_queries,
+                token_status_queries,
                 transaction,
                 platform_version,
             ),

packages/rs-drive/src/prove/prove_multiple_state_transition_results/v0/mod.rs

@@ -3,6 +3,9 @@ use crate::drive::Drive;
 use crate::error::Error;
 use crate::query::{IdentityBasedVoteDriveQuery, SingleDocumentDriveQuery};
 
+use crate::query::identity_token_balance_drive_query::IdentityTokenBalanceDriveQuery;
+use crate::query::identity_token_info_drive_query::IdentityTokenInfoDriveQuery;
+use crate::query::token_status_drive_query::TokenStatusDriveQuery;
 use dpp::version::PlatformVersion;
 use grovedb::{PathQuery, TransactionArg};
 use itertools::{Either, Itertools};
@@ -18,6 +21,12 @@ impl Drive {
     ///   to be proven.
     /// - `vote_queries`: A list of [IdentityBasedVoteDriveQuery]. These would be to figure out the
     ///   result of votes based on identities making them.
+    /// - `token_balance_queries`: A slice of [IdentityTokenBalanceDriveQuery] objects specifying
+    ///   token balance queries for identities.
+    /// - `token_info_queries`: A slice of [IdentityTokenInfoDriveQuery] objects specifying
+    ///   token information queries for identities.
+    /// - `token_status_queries`: A slice of [TokenStatusDriveQuery] objects specifying token
+    ///   status queries.
     /// - `transaction`: An optional grovedb transaction
     /// - `platform_version`: A reference to the [PlatformVersion] object that specifies the version of
     ///   the function to call.
@@ -32,6 +41,9 @@ impl Drive {
         contract_ids: &[([u8; 32], Option<bool>)], //bool is history
         document_queries: &[SingleDocumentDriveQuery],
         vote_queries: &[IdentityBasedVoteDriveQuery],
+        token_balance_queries: &[IdentityTokenBalanceDriveQuery],
+        token_info_queries: &[IdentityTokenInfoDriveQuery],
+        token_status_queries: &[TokenStatusDriveQuery],
         transaction: TransactionArg,
         platform_version: &PlatformVersion,
     ) -> Result<Vec<u8>, Error> {
@@ -108,6 +120,44 @@ impl Drive {
             }));
         }
 
+        if !token_balance_queries.is_empty() {
+            path_queries.extend(
+                token_balance_queries
+                    .iter()
+                    .filter_map(|token_balance_query| {
+                        // The path query construction can only fail if the serialization fails.
+                        // Because the serialization will pretty much never fail, we can do this.
+                        let mut path_query = token_balance_query.construct_path_query();
+                        path_query.query.limit = None;
+                        Some(path_query)
+                    }),
+            );
+        }
+
+        if !token_info_queries.is_empty() {
+            path_queries.extend(token_info_queries.iter().filter_map(|token_info_query| {
+                // The path query construction can only fail if the serialization fails.
+                // Because the serialization will pretty much never fail, we can do this.
+                let mut path_query = token_info_query.construct_path_query();
+                path_query.query.limit = None;
+                Some(path_query)
+            }));
+        }
+
+        if !token_status_queries.is_empty() {
+            path_queries.extend(
+                token_status_queries
+                    .iter()
+                    .filter_map(|token_status_query| {
+                        // The path query construction can only fail if the serialization fails.
+                        // Because the serialization will pretty much never fail, we can do this.
+                        let mut path_query = token_status_query.construct_path_query();
+                        path_query.query.limit = None;
+                        Some(path_query)
+                    }),
+            );
+        }
+
         let path_query = PathQuery::merge(
             path_queries.iter().collect(),
             &platform_version.drive.grove_version,