drive_proof_verifier/proof/
identity_token_balance.rs

1use crate::error::MapGroveDbError;
2use crate::types::identity_token_balance::{IdentitiesTokenBalances, IdentityTokenBalances};
3use crate::verify::verify_tenderdash_proof;
4use crate::{ContextProvider, Error, FromProof};
5use dapi_grpc::platform::v0::{
6    get_identities_token_balances_request, get_identity_token_balances_request,
7    GetIdentitiesTokenBalancesRequest, GetIdentitiesTokenBalancesResponse,
8    GetIdentityTokenBalancesRequest, GetIdentityTokenBalancesResponse, Proof, ResponseMetadata,
9};
10use dapi_grpc::platform::VersionedGrpcResponse;
11use dpp::dashcore::Network;
12use dpp::version::PlatformVersion;
13use drive::drive::Drive;
14
15impl FromProof<GetIdentityTokenBalancesRequest> for IdentityTokenBalances {
16    type Request = GetIdentityTokenBalancesRequest;
17    type Response = GetIdentityTokenBalancesResponse;
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_balances_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_balances_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<GetIdentitiesTokenBalancesRequest> for IdentitiesTokenBalances {
75    type Request = GetIdentitiesTokenBalancesRequest;
76    type Response = GetIdentitiesTokenBalancesResponse;
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_balances_request::Version::V0(v0) => {
93                let token_id = <[u8; 32]>::try_from(v0.token_id.as_slice()).map_err(|error| {
94                    Error::RequestError {
95                        error: error.to_string(),
96                    }
97                })?;
98
99                let identity_ids = v0
100                    .identity_ids
101                    .into_iter()
102                    .map(<[u8; 32]>::try_from)
103                    .collect::<Result<Vec<_>, _>>()
104                    .map_err(|_| Error::RequestError {
105                        error: "can't convert identity_id to [u8; 32]".to_string(),
106                    })?;
107
108                (token_id, identity_ids)
109            }
110        };
111
112        let metadata = response
113            .metadata()
114            .or(Err(Error::EmptyResponseMetadata))?
115            .clone();
116
117        let proof = response.proof_owned().or(Err(Error::NoProofInResult))?;
118
119        let (root_hash, result) = Drive::verify_token_balances_for_identity_ids(
120            &proof.grovedb_proof,
121            token_id,
122            &identity_ids,
123            false,
124            platform_version,
125        )
126        .map_drive_error(&proof, &metadata)?;
127
128        verify_tenderdash_proof(&proof, &metadata, &root_hash, provider)?;
129
130        Ok((Some(result), metadata, proof))
131    }
132}
drive_proof_verifier/proof/identity_token_balance.rs

drive_proof_verifier/proof/
identity_token_balance.rs
