drive_proof_verifier/proof/
token_info.rs

1use crate::error::MapGroveDbError;
2use crate::types::token_info::{IdentitiesTokenInfos, IdentityTokenInfos};
3use crate::verify::verify_tenderdash_proof;
4use crate::{ContextProvider, Error, FromProof};
5use dapi_grpc::platform::v0::{
6    get_identities_token_infos_request, get_identity_token_infos_request,
7    GetIdentitiesTokenInfosRequest, GetIdentitiesTokenInfosResponse, GetIdentityTokenInfosRequest,
8    GetIdentityTokenInfosResponse, Proof, ResponseMetadata,
9};
10use dapi_grpc::platform::VersionedGrpcResponse;
11use dpp::dashcore::Network;
12use dpp::version::PlatformVersion;
13use drive::drive::Drive;
14
15impl FromProof<GetIdentityTokenInfosRequest> for IdentityTokenInfos {
16    type Request = GetIdentityTokenInfosRequest;
17    type Response = GetIdentityTokenInfosResponse;
18
19    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
20        request: I,
21        response: O,
22        _network: Network,
23        platform_version: &PlatformVersion,
24        provider: &'a dyn ContextProvider,
25    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
26    where
27        Self: Sized + 'a,
28    {
29        let request: Self::Request = request.into();
30        let response: Self::Response = response.into();
31
32        let (token_ids, identity_id) = match request.version.ok_or(Error::EmptyVersion)? {
33            get_identity_token_infos_request::Version::V0(v0) => {
34                let identity_id =
35                    <[u8; 32]>::try_from(v0.identity_id).map_err(|_| Error::RequestError {
36                        error: "can't convert identity_id to [u8; 32]".to_string(),
37                    })?;
38
39                let token_ids = v0
40                    .token_ids
41                    .into_iter()
42                    .map(<[u8; 32]>::try_from)
43                    .collect::<Result<Vec<_>, _>>()
44                    .map_err(|_| Error::RequestError {
45                        error: "can't convert token_id to [u8; 32]".to_string(),
46                    })?;
47
48                (token_ids, identity_id)
49            }
50        };
51
52        let metadata = response
53            .metadata()
54            .or(Err(Error::EmptyResponseMetadata))?
55            .clone();
56
57        let proof = response.proof_owned().or(Err(Error::NoProofInResult))?;
58
59        let (root_hash, result) = Drive::verify_token_infos_for_identity_id(
60            &proof.grovedb_proof,
61            &token_ids,
62            identity_id,
63            false,
64            platform_version,
65        )
66        .map_drive_error(&proof, &metadata)?;
67
68        verify_tenderdash_proof(&proof, &metadata, &root_hash, provider)?;
69
70        Ok((Some(result), metadata, proof))
71    }
72}
73
74impl FromProof<GetIdentitiesTokenInfosRequest> for IdentitiesTokenInfos {
75    type Request = GetIdentitiesTokenInfosRequest;
76    type Response = GetIdentitiesTokenInfosResponse;
77
78    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
79        request: I,
80        response: O,
81        _network: Network,
82        platform_version: &PlatformVersion,
83        provider: &'a dyn ContextProvider,
84    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
85    where
86        Self: Sized + 'a,
87    {
88        let request: Self::Request = request.into();
89        let response: Self::Response = response.into();
90
91        let (token_id, identity_ids) = match request.version.ok_or(Error::EmptyVersion)? {
92            get_identities_token_infos_request::Version::V0(v0) => {
93                let token_id =
94                    <[u8; 32]>::try_from(v0.token_id.clone()).map_err(|_| Error::RequestError {
95                        error: "can't convert token_id to [u8; 32]".to_string(),
96                    })?;
97
98                let identity_ids = v0
99                    .identity_ids
100                    .into_iter()
101                    .map(<[u8; 32]>::try_from)
102                    .collect::<Result<Vec<_>, _>>()
103                    .map_err(|_| Error::RequestError {
104                        error: "can't convert identity_id to [u8; 32]".to_string(),
105                    })?;
106
107                (token_id, identity_ids)
108            }
109        };
110
111        let metadata = response
112            .metadata()
113            .or(Err(Error::EmptyResponseMetadata))?
114            .clone();
115
116        let proof = response.proof_owned().or(Err(Error::NoProofInResult))?;
117
118        let (root_hash, result) = Drive::verify_token_infos_for_identity_ids(
119            &proof.grovedb_proof,
120            token_id,
121            &identity_ids,
122            false,
123            platform_version,
124        )
125        .map_drive_error(&proof, &metadata)?;
126
127        verify_tenderdash_proof(&proof, &metadata, &root_hash, provider)?;
128
129        Ok((Some(result), metadata, proof))
130    }
131}
drive_proof_verifier/proof/token_info.rs

drive_proof_verifier/proof/
token_info.rs
