Skip to main content

drive_proof_verifier/proof/
private_document_entries.rs

1//! Proof verification of a page of the entries of a private document type's store.
2
3use 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    /// A request asking for no proof is answered without one, which no proof can verify: it
25    /// is read with `FromUnproved` instead.
26    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        // The type and its entry size come from the contract, which the client trusts; the
64        // store's chunk power, which settles the page, from the store element the proof binds.
65        // A contract the client's context does not hold with this private type is the
66        // client's to refresh, not a fault of the node answering.
67        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        // A page always carries the store's count, so a proved page is never absent
98        Ok((Some(page), metadata, proof))
99    }
100}