drive_proof_verifier/proof/
private_document_entries.rs1use crate::error::MapGroveDbError;
4use crate::types::contract_moderation::identifier_from_request;
5use crate::types::private_document_entries::PrivateDocumentEntries;
6use crate::verify::{document_query_proof_bytes, verify_tenderdash_proof};
7use crate::{ContextProvider, Error, FromProof};
8use dapi_grpc::platform::v0::{
9 get_private_document_entries_request, GetPrivateDocumentEntriesRequest,
10 GetPrivateDocumentEntriesResponse, Proof, ResponseMetadata,
11};
12use dapi_grpc::platform::VersionedGrpcResponse;
13use dash_context_provider::ContextProviderError;
14use dpp::dashcore::Network;
15use dpp::data_contract::accessors::v0::DataContractV0Getters;
16use dpp::data_contract::document_type::accessors::DocumentTypeV2Getters;
17use dpp::version::PlatformVersion;
18use drive::drive::Drive;
19
20impl FromProof<GetPrivateDocumentEntriesRequest> for PrivateDocumentEntries {
21 type Request = GetPrivateDocumentEntriesRequest;
22 type Response = GetPrivateDocumentEntriesResponse;
23
24 fn check_request(
27 request: &Self::Request,
28 _platform_version: &PlatformVersion,
29 ) -> Result<(), Error> {
30 match &request.version {
31 Some(get_private_document_entries_request::Version::V0(v0)) if !v0.prove => {
32 Err(Error::RequestError {
33 error: "the request asks for no proof: read it unproved".to_string(),
34 })
35 }
36 _ => Ok(()),
37 }
38 }
39
40 fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
41 request: I,
42 response: O,
43 _network: Network,
44 platform_version: &PlatformVersion,
45 provider: &'a dyn ContextProvider,
46 ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
47 where
48 Self: Sized + 'a,
49 {
50 let request: Self::Request = request.into();
51 let response: Self::Response = response.into();
52
53 let get_private_document_entries_request::Version::V0(v0) =
54 request.version.ok_or(Error::EmptyVersion)?;
55 let contract_id = identifier_from_request(&v0.data_contract_id, "data_contract_id")?;
56
57 let metadata = response
58 .metadata()
59 .or(Err(Error::EmptyResponseMetadata))?
60 .clone();
61 let proof = response.proof_owned().or(Err(Error::NoProofInResult))?;
62
63 let data_contract = provider
68 .get_data_contract(&contract_id, platform_version)?
69 .ok_or_else(|| {
70 Error::ContextProviderError(ContextProviderError::DataContractFailure(format!(
71 "the context holds no data contract {contract_id}"
72 )))
73 })?;
74 let document_type = data_contract
75 .document_type_for_name(&v0.document_type_name)
76 .ok()
77 .filter(|document_type| document_type.private_document().is_some())
78 .ok_or_else(|| {
79 Error::ContextProviderError(ContextProviderError::DataContractFailure(format!(
80 "the context's data contract {contract_id} has no private document type \
81 \"{}\"",
82 v0.document_type_name
83 )))
84 })?;
85
86 let (root_hash, page) = Drive::verify_private_document_entries(
87 document_query_proof_bytes(&proof, &metadata, platform_version)?,
88 contract_id.to_buffer(),
89 document_type,
90 v0.start_position,
91 platform_version,
92 )
93 .map_drive_error(&proof, &metadata)?;
94
95 verify_tenderdash_proof(&proof, &metadata, &root_hash, provider)?;
96
97 Ok((Some(page), metadata, proof))
99 }
100}