drive_proof_verifier/

proof.rs

/// Verified chained-document (provable semi-join) result: two grovedb
/// proofs — the inner indexOnly page and the outer by-ids fetch derived
/// from its proven values — bound to one quorum-signed root.
pub mod chained_document;
/// Verified composite-document result: a page plus the sub-queries
/// derived from it (joins, lookups, counts, siblings), ONE merged
/// grovedb proof bound to one quorum-signed root.
pub mod composite_document;
pub mod contract_groups;
pub mod contract_moderation;
pub mod data_contracts_by_range;
pub mod data_contracts_latest_versions;
/// Verified average result. Holds the `(count, sum)` pair recovered
/// from a `CountSumTree` / PCPS proof; client divides to obtain the
/// average. Lights up alongside grovedb PR 670's
/// `AggregateCountAndSumOnRange` primitive.
pub mod document_average;
pub mod document_count;
/// Verified having-range (`GROUP BY … HAVING <aggregate> <op> <value>
/// LIMIT n`) result. One entry per matching group, in axis order, read
/// as a value-bounded range of an indexed tree's per-axis secondary
/// (grovedb PR 657); see the file's docs.
pub mod document_having;
/// Verified ranked (`GROUP BY … ORDER BY <aggregate> LIMIT n
/// [OFFSET m]`) result. One entry per returned group, in ranking order,
/// plus the attested rank the page starts at, read from an indexed
/// tree's per-axis secondary (grovedb PR 657); see the file's docs.
pub mod document_ranked;
/// Per-entry verified average result. One `(in_key, key, count, sum)`
/// tuple per matched group; client divides per-entry to obtain
/// per-group averages.
pub mod document_split_average;
pub mod document_split_count;
/// Per-entry verified sum result (sum-side analog of
/// `document_split_count`). One `(in_key, key, sum)` triple per
/// matched group. Lights up alongside grovedb PR 670.
pub mod document_split_sum;
/// Verified sum result (sum-side analog of `document_count`).
/// Single-value aggregate sum recovered from a sum-tree proof.
/// Lights up alongside grovedb PR 670; see the file's docs.
pub mod document_sum;
pub mod groups;
pub mod identity_keys_remaining_budgets;
pub mod identity_token_balance;
pub mod token_contract_info;
pub mod token_direct_purchase;
pub mod token_info;
pub mod token_perpetual_distribution_last_claim;
pub mod token_pre_programmed_distributions;
pub mod token_status;
pub mod token_total_supply;

use crate::from_request::TryFromRequest;
use crate::verify::{
    document_query_proof_bytes, supported_grovedb_proof_bytes, require_supported_grovedb_proof_bytes, verify_page_drive_proves, verify_tenderdash_proof, verify_tenderdash_signature,
};
use crate::{types::*, ContextProvider, DataContractProvider, Error};
use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_range_request::get_evonodes_proposed_epoch_blocks_by_range_request_v0::Start;
use dapi_grpc::platform::v0::get_identities_contract_keys_request::GetIdentitiesContractKeysRequestV0;
use dapi_grpc::platform::v0::get_identity_by_non_unique_public_key_hash_response::{
    get_identity_by_non_unique_public_key_hash_response_v0::Result as NonUniqueLookupV0Result,
    get_identity_by_non_unique_public_key_hash_response_v1::Result as NonUniqueLookupV1Result,
    Version as NonUniqueLookupVersion,
};
use dapi_grpc::platform::v0::get_path_elements_request::GetPathElementsRequestV0;
use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_request::{
    self, GetProtocolVersionUpgradeVoteStatusRequestV0,
};
use dapi_grpc::platform::v0::security_level_map::KeyKindRequestType as GrpcKeyKind;
use dapi_grpc::platform::v0::{
    get_address_info_request, get_addresses_infos_request,
    get_contested_resource_identity_votes_request, get_data_contract_history_request, get_data_contract_request, get_data_contracts_request, get_document_history_request, get_epochs_info_request, get_evonodes_proposed_epoch_blocks_by_ids_request, get_evonodes_proposed_epoch_blocks_by_range_request, get_finalized_epoch_infos_request, get_identities_balances_request, get_identities_contract_keys_request, get_identity_balance_and_revision_request, get_identity_balance_request, get_identity_by_non_unique_public_key_hash_request,
    get_identity_by_public_key_hash_request, get_identity_contract_nonce_request, get_identity_keys_request, get_identity_nonce_request, get_identity_request, get_path_elements_request, get_prefunded_specialized_balance_request, GetContestedResourceVotersForIdentityRequest, GetContestedResourceVotersForIdentityResponse, GetPathElementsRequest, GetPathElementsResponse, GetProtocolVersionUpgradeStateRequest, GetProtocolVersionUpgradeStateResponse, GetProtocolVersionUpgradeVoteStatusRequest, GetProtocolVersionUpgradeVoteStatusResponse, Proof, ResponseMetadata
};
use dapi_grpc::platform::{
    v0::{self as platform, key_request_type, KeyRequestType as GrpcKeyType},
    VersionedGrpcResponse,
};
use dpp::address_funds::PlatformAddress;
use dpp::block::block_info::BlockInfo;
use dpp::block::epoch::EpochIndex;
use dpp::block::extended_epoch_info::ExtendedEpochInfo;
use dpp::core_subsidy::NetworkCoreSubsidy;
use dpp::data_contract::accessors::v0::DataContractV0Getters;
use dpp::dashcore::hashes::Hash;
use dpp::dashcore::{Network, ProTxHash};
use dpp::document::{Document, DocumentV0Getters};
use dpp::fee::Credits;
use dpp::identity::identities_contract_keys::IdentitiesContractKeys;
use dpp::identity::Purpose;
use dpp::platform_value::{self};
use dpp::prelude::{AddressNonce, DataContract, Identifier, Identity};
use dpp::serialization::PlatformDeserializableUntrusted;
use dpp::state_transition::proof_result::StateTransitionProofOutcome;
use dpp::state_transition::StateTransition;
use dpp::version::{PlatformVersion, LATEST_VERSION};
use dpp::voting::votes::Vote;
use drive::drive::identity::key::fetch::{
    IdentityKeysRequest, KeyKindRequestType, KeyRequestType, PurposeU8, SecurityLevelU8,
};
use drive::drive::Drive;
use drive::error::proof::ProofError;
use drive::grovedb::GroveTrunkQueryResult;
use drive::query::contested_resource_votes_given_by_identity_query::ContestedResourceVotesGivenByIdentityQuery;
use drive::query::proposer_block_count_query::ProposerQueryType;
use drive::query::vote_poll_contestant_votes_query::{
    ContestedDocumentVotePollVotesDriveQuery, ResolvedContestedDocumentVotePollVotesDriveQuery,
};
use drive::query::vote_poll_vote_state_query::{
    ContestedDocumentVotePollDriveQuery, ResolvedContestedDocumentVotePollDriveQuery,
};
use drive::query::vote_polls_by_document_type_query::{
    ResolvedVotePollsByDocumentTypeQuery, VotePollsByDocumentTypeQuery,
};
use drive::query::{DriveDocumentQuery, VotePollsByEndDateDriveQuery};
use indexmap::IndexMap;
use std::array::TryFromSliceError;
use std::collections::BTreeMap;
use std::num::TryFromIntError;
use crate::error::MapGroveDbError;

/// Parse and verify the received proof and retrieve the requested object, if any.
///
/// Use [`FromProof::maybe_from_proof()`] or [`FromProof::from_proof()`] to parse and verify proofs received
/// from the Dash Platform (including verification of grovedb-generated proofs and cryptographic proofs generated
/// by Tenderdash).
///
/// gRPC responses, received from the Dash Platform in response to requests containing `prove: true`, contain
/// GroveDB proof structure (including encapsulated objects) and metadata required to verify cryptographic proof
/// generated by the Tenderdash. This trait provides methods that parse and verify the proof and retrieve the requested
/// object (or information that the object does not exist) in one step.
///
/// This trait is implemented by several objects defined in [Dash Platform Protocol](dpp), like [Identity],
/// [DataContract], [Documents], etc. It is also implemented by several helper objects from [types] module.
pub trait FromProof<Req> {
    /// Request type for which this trait is implemented.
    type Request;
    /// Response type for which this trait is implemented.
    type Response;

    /// Parse and verify the received proof and retrieve the requested object, if any.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using, Mainnet/Testnet/Devnet or Regtest
    /// * `platform_version`: The platform version that should be used.
    /// * `provider`: A callback implementing [ContextProvider] that provides quorum details required to verify the proof.
    ///
    /// # Returns
    ///
    /// * `Ok(Some(object, metadata))` when the requested object was found in the proof.
    /// * `Ok(None)` when the requested object was not found in the proof; this can be interpreted as proof of non-existence.
    ///   For collections, returns Ok(None) if none of the requested objects were found.
    /// * `Err(Error)` when either the provided data is invalid or proof validation failed.
    fn maybe_from_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<Option<Self>, Error>
    where
        Self: Sized + 'a,
    {
        Self::maybe_from_proof_with_metadata(request, response, network, platform_version, provider)
            .map(|maybe_result| maybe_result.0)
    }

    /// Parse and verify the received proof and retrieve the requested object, if any.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using, Mainnet/Testnet/Devnet or Regtest
    /// * `platform_version`: The platform version that should be used.
    /// * `provider`: A callback implementing [ContextProvider] that provides quorum details required to verify the proof.
    ///
    /// # Returns
    ///
    /// * `Ok(Some((object, metadata)))` when the requested object was found in the proof.
    /// * `Ok(None)` when the requested object was not found in the proof; this can be interpreted as proof of non-existence.
    ///   For collections, returns Ok(None) if none of the requested objects were found.
    /// * `Err(Error)` when either the provided data is invalid or proof validation failed.
    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a;

    /// Check, before the request is sent, that this type can be verified from an answer to it.
    ///
    /// Several types can share one request type while each accepting only some of its shapes
    /// (every document view is fetched with the same document query). A shape refused only
    /// after the answer is reported as a failed proof, which callers retry on another node
    /// and hold against the one that answered, although that node answered it correctly.
    /// Refusing it here keeps it off the network.
    ///
    /// The default accepts every request. An implementation must not refuse a request that
    /// [`FromProof::maybe_from_proof_with_metadata()`] can verify at `platform_version` or at
    /// any later version: an answer is verified at the version it is signed with when that
    /// is newer.
    ///
    /// # Arguments
    ///
    /// * `request`: The request that is about to be sent.
    /// * `platform_version`: The platform version the request is built for.
    ///
    /// # Returns
    ///
    /// * `Ok(())` when the request can be sent.
    /// * `Err(Error)` when no answer to the request can be verified as this type.
    fn check_request(
        _request: &Self::Request,
        _platform_version: &PlatformVersion,
    ) -> Result<(), Error>
    where
        Self: Sized,
    {
        Ok(())
    }

    /// Retrieve the requested object from the proof.
    ///
    /// Runs full verification of the proof and retrieves enclosed objects.
    ///
    /// This method uses [`FromProof::maybe_from_proof()`] internally and throws an error
    /// if the requested object does not exist in the proof.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using, Mainnet/Testnet/Devnet or Regtest
    /// * `platform_version`: The platform version that should be used.
    /// * `provider`: A callback implementing [ContextProvider] that provides quorum details required to verify the proof.
    ///
    /// # Returns
    ///
    /// * `Ok(object)` when the requested object was found in the proof.
    /// * `Err(Error::DocumentMissingInProof)` when the requested object was not found in the proof.
    /// * `Err(Error)` when either the provided data is invalid or proof validation failed.
    fn from_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<Self, Error>
    where
        Self: Sized + 'a,
    {
        Self::maybe_from_proof(request, response, network, platform_version, provider)?
            .ok_or(Error::NotFound)
    }

    /// Retrieve the requested object from the proof with metadata.
    ///
    /// Runs full verification of the proof and retrieves enclosed objects.
    ///
    /// This method uses [`FromProof::maybe_from_proof_with_metadata()`] internally and throws an error
    /// if the requested object does not exist in the proof.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using, Mainnet/Testnet/Devnet or Regtest
    /// * `platform_version`: The platform version that should be used.
    /// * `provider`: A callback implementing [ContextProvider] that provides quorum details required to verify the proof.
    ///
    /// # Returns
    ///
    /// * `Ok(Some(object, metadata))` when the requested object was found in the proof.
    /// * `Err(Error::DocumentMissingInProof)` when the requested object was not found in the proof.
    /// * `Err(Error)` when either the provided data is invalid or proof validation failed.
    fn from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Self, ResponseMetadata), Error>
    where
        Self: Sized + 'a,
    {
        let (main_item, response_metadata, _) = Self::maybe_from_proof_with_metadata(
            request,
            response,
            network,
            platform_version,
            provider,
        )?;
        Ok((main_item.ok_or(Error::NotFound)?, response_metadata))
    }

    /// Retrieve the requested object from the proof with metadata.
    ///
    /// Runs full verification of the proof and retrieves enclosed objects.
    ///
    /// This method uses [`FromProof::maybe_from_proof_with_metadata()`] internally and throws an error
    /// if the requested object does not exist in the proof.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using, Mainnet/Testnet/Devnet or Regtest
    /// * `platform_version`: The platform version that should be used.
    /// * `provider`: A callback implementing [ContextProvider] that provides quorum details required to verify the proof.
    ///
    /// # Returns
    ///
    /// * `Ok(Some(object, metadata, proof))` when the requested object was found in the proof.
    /// * `Err(Error::DocumentMissingInProof)` when the requested object was not found in the proof.
    /// * `Err(Error)` when either the provided data is invalid or proof validation failed.
    fn from_proof_with_metadata_and_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Self, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let (main_item, response_metadata, proof) = Self::maybe_from_proof_with_metadata(
            request,
            response,
            network,
            platform_version,
            provider,
        )?;
        Ok((main_item.ok_or(Error::NotFound)?, response_metadata, proof))
    }
}

impl FromProof<platform::GetIdentityRequest> for Identity {
    type Request = platform::GetIdentityRequest;
    type Response = platform::GetIdentityResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Identity: Sized + 'a,
    {
        let request: platform::GetIdentityRequest = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let id = match request.version.ok_or(Error::EmptyVersion)? {
            get_identity_request::Version::V0(v0) => {
                Identifier::from_bytes(&v0.id).map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                })?
            }
        };

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) = Drive::verify_full_identity_by_identity_id(
            supported_grovedb_proof_bytes(proof)?,
            false,
            id.into_buffer(),
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_identity, mtd.clone(), proof.clone()))
    }
}

// TODO: figure out how to deal with mock::automock
impl FromProof<platform::GetIdentityByPublicKeyHashRequest> for Identity {
    type Request = platform::GetIdentityByPublicKeyHashRequest;
    type Response = platform::GetIdentityByPublicKeyHashResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Identity: 'a,
    {
        let request = request.into();
        let response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let public_key_hash = match request.version.ok_or(Error::EmptyVersion)? {
            get_identity_by_public_key_hash_request::Version::V0(v0) => {
                let public_key_hash: [u8; 20] =
                    v0.public_key_hash
                        .try_into()
                        .map_err(|_| Error::DriveError {
                            error: "Invalid public key hash length".to_string(),
                        })?;
                public_key_hash
            }
        };

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) = Drive::verify_full_identity_by_unique_public_key_hash(
            supported_grovedb_proof_bytes(proof)?,
            public_key_hash,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_identity, mtd.clone(), proof.clone()))
    }
}

// The producer's signed version selects how the producer laid out its proof, while
// security checks keep the caller's verifier version. For the non-unique identity
// lookup it selects the GroveDB version its merged queries are built with and, for a
// two-proof answer, the tables that decode the identity after the strict checks. For a
// state transition outcome it selects only whether the proof carries the owner balance:
// every key and query is rebuilt with the caller's rules. Metadata is untrusted until
// the signature binds it to the root. A producer newer than this build is read with the
// newest known tables, the same fallback the SDK uses for verifier tables. A wrong guess
// cannot authenticate data the signed root does not hold, and a changed layout is
// expected to fail verification for answers that return data. An absence answer can
// still verify at a location a newer protocol no longer uses, so relocating such an
// index needs an SDK update. Reserved mock versions also sit above the newest one, so
// their tables are never looked up.
fn proof_query_platform_version(
    metadata: &ResponseMetadata,
) -> Result<&'static PlatformVersion, Error> {
    if metadata.protocol_version > LATEST_VERSION {
        return Ok(PlatformVersion::latest());
    }
    PlatformVersion::get(metadata.protocol_version).map_err(|_| Error::ResponseDecodeError {
        error: format!(
            "unsupported proof query protocol version {}",
            metadata.protocol_version
        ),
    })
}

impl FromProof<platform::GetIdentityByNonUniquePublicKeyHashRequest> for Identity {
    type Request = platform::GetIdentityByNonUniquePublicKeyHashRequest;
    type Response = platform::GetIdentityByNonUniquePublicKeyHashResponse;
    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request = request.into();
        let response = response.into();
        // A V0 answer carries separate index and identity proofs, a V1 answer one proof.
        // The index proof of a V0 answer is the one carrying the quorum signature.
        let (proof, identity_proof, mtd, answered_with_two_proofs) = match &response.version {
            Some(NonUniqueLookupVersion::V0(v0)) => {
                let Some(NonUniqueLookupV0Result::Proof(proved)) = &v0.result else {
                    return Err(Error::NoProofInResult);
                };
                (
                    proved
                        .grovedb_identity_public_key_hash_proof
                        .as_ref()
                        .ok_or(Error::NoProofInResult)?,
                    proved.identity_proof_bytes.as_deref(),
                    v0.metadata.as_ref(),
                    true,
                )
            }
            Some(NonUniqueLookupVersion::V1(v1)) => {
                let Some(NonUniqueLookupV1Result::Proof(proof)) = &v1.result else {
                    return Err(Error::NoProofInResult);
                };
                (proof, None, v1.metadata.as_ref(), false)
            }
            None => return Err(Error::NoProofInResult),
        };
        let mtd = mtd.ok_or(Error::EmptyResponseMetadata)?;
        let (public_key_hash, start_after, two_proofs_requested) =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_identity_by_non_unique_public_key_hash_request::Version::V0(v0) => {
                    (v0.public_key_hash, v0.start_after, true)
                }
                get_identity_by_non_unique_public_key_hash_request::Version::V1(v1) => {
                    (v1.public_key_hash, v1.start_after, false)
                }
            };
        let public_key_hash = public_key_hash
            .try_into()
            .map_err(|_| Error::RequestError {
                error: "Invalid public key hash length".to_string(),
            })?;
        let after_identity = start_after
            .map(|a| {
                a.try_into().map_err(|_| Error::RequestError {
                    error: "Invalid start_after length".to_string(),
                })
            })
            .transpose()?;

        // The request version chooses the proof shape, and the answer must come in it.
        // The quorum signature covers the state, not the envelope, so an answer in the
        // other shape is refused rather than reinterpreted.
        if two_proofs_requested != answered_with_two_proofs {
            return Err(Error::ResponseDecodeError {
                error: "non-unique identity response version does not match request version"
                    .to_string(),
            });
        }

        let query_platform_version = proof_query_platform_version(mtd)?;
        let bytes = supported_grovedb_proof_bytes(proof)?;
        let verified = if answered_with_two_proofs {
            Drive::verify_full_identity_by_non_unique_public_key_hash_two_proofs(
                bytes,
                identity_proof,
                public_key_hash,
                after_identity,
                query_platform_version,
                platform_version,
            )
        } else {
            Drive::verify_full_identity_by_non_unique_public_key_hash(
                bytes,
                public_key_hash,
                after_identity,
                query_platform_version,
                platform_version,
            )
        };
        let (root_hash, maybe_identity) = verified.map_drive_error(proof, mtd)?;
        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;
        Ok((maybe_identity, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetIdentityKeysRequest> for IdentityPublicKeys {
    type Request = platform::GetIdentityKeysRequest;
    type Response = platform::GetIdentityKeysResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityPublicKeys: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (request_type, identity_id, limit, offset) =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_identity_keys_request::Version::V0(v0) => {
                    let request_type = v0.request_type;
                    let identity_id = Identifier::from_bytes(&v0.identity_id)
                        .map_err(|e| Error::ProtocolError {
                            error: e.to_string(),
                        })?
                        .into_buffer();
                    let limit = v0.limit.map(try_u32_to_u16).transpose()?;
                    let offset = v0.offset.map(try_u32_to_u16).transpose()?;
                    (request_type, identity_id, limit, offset)
                }
            };

        let request_type = parse_key_request_type(&request_type)?;

        let key_request = IdentityKeysRequest {
            identity_id,
            request_type,
            limit,
            offset,
        };

        tracing::debug!(?identity_id, "checking proof of identity keys");

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) = Drive::verify_identity_keys_by_identity_id(
            supported_grovedb_proof_bytes(proof)?,
            key_request,
            false,
            false,
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        let maybe_keys: Option<IdentityPublicKeys> = if let Some(identity) = maybe_identity {
            if identity.loaded_public_keys.is_empty() {
                None
            } else {
                let mut keys = identity
                    .loaded_public_keys
                    .into_iter()
                    .map(|(k, v)| (k, Some(v.clone())))
                    .collect::<IdentityPublicKeys>();

                let mut not_found = identity
                    .not_found_public_keys
                    .into_iter()
                    .map(|k| (k, None))
                    .collect::<IdentityPublicKeys>();

                keys.append(&mut not_found);

                Some(keys)
            }
        } else {
            None
        };

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_keys, mtd.clone(), proof.clone()))
    }
}

fn parse_key_request_type(request: &Option<GrpcKeyType>) -> Result<KeyRequestType, Error> {
    let key_request_type = request
        .to_owned()
        .ok_or(Error::RequestError {
            error: "missing key request type".to_string(),
        })?
        .request
        .ok_or(Error::RequestError {
            error: "empty request field in key request type".to_string(),
        })?;

    let request_type = match key_request_type {
        key_request_type::Request::AllKeys(_) => KeyRequestType::AllKeys,
        key_request_type::Request::SpecificKeys(specific_keys) => {
            KeyRequestType::SpecificKeys(specific_keys.key_ids)
        }
        key_request_type::Request::SearchKey(search_key) => {
            let purpose = search_key
                .purpose_map
                .iter()
                .map(|(k, v)| {
                     let v = v.security_level_map
                            .iter()
                            .map(|(level, &kind)| {
                                let kt = match GrpcKeyKind::try_from(kind) {
                                    Ok(GrpcKeyKind::CurrentKeyOfKindRequest) => {
                                        Ok(KeyKindRequestType::CurrentKeyOfKindRequest)
                                    }
                                    Ok(GrpcKeyKind::AllKeysOfKindRequest) => {
                                        Ok(KeyKindRequestType::AllKeysOfKindRequest)
                                    }
                                    _ => Err(Error::RequestError {
                                        error: format!("missing requested key type: {}", kind),
                                    }),
                                };
                                match kt  {
                                    Err(e) => Err(e),
                                    Ok(d) => Ok((*level as u8, d))
                                }
                            })
                            .collect::<Result<BTreeMap<SecurityLevelU8,KeyKindRequestType>,Error>>();

                            match v {
                                Err(e) =>Err(e),
                                Ok(d) => Ok((*k as u8,d)),
                            }
                })
                .collect::<Result<BTreeMap<PurposeU8, BTreeMap<SecurityLevelU8, KeyKindRequestType>>,Error>>()?;

            KeyRequestType::SearchKey(purpose)
        }
    };

    Ok(request_type)
}

impl FromProof<platform::GetIdentityNonceRequest> for IdentityNonceFetcher {
    type Request = platform::GetIdentityNonceRequest;
    type Response = platform::GetIdentityNonceResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityNonceFetcher: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let identity_id =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_identity_nonce_request::Version::V0(v0) => Ok::<Identifier, Error>(
                    Identifier::from_bytes(&v0.identity_id).map_err(|e| Error::ProtocolError {
                        error: e.to_string(),
                    })?,
                ),
            }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_nonce) = Drive::verify_identity_nonce(
            supported_grovedb_proof_bytes(proof)?,
            identity_id.into_buffer(),
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_nonce.map(IdentityNonceFetcher),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetIdentityContractNonceRequest> for IdentityContractNonceFetcher {
    type Request = platform::GetIdentityContractNonceRequest;
    type Response = platform::GetIdentityContractNonceResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityContractNonceFetcher: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (identity_id, contract_id) = match request.version.ok_or(Error::EmptyVersion)? {
            get_identity_contract_nonce_request::Version::V0(v0) => {
                Ok::<(Identifier, Identifier), Error>((
                    Identifier::from_bytes(&v0.identity_id).map_err(|e| Error::ProtocolError {
                        error: e.to_string(),
                    })?,
                    Identifier::from_bytes(&v0.contract_id).map_err(|e| Error::ProtocolError {
                        error: e.to_string(),
                    })?,
                ))
            }
        }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) = Drive::verify_identity_contract_nonce(
            supported_grovedb_proof_bytes(proof)?,
            identity_id.into_buffer(),
            contract_id.into_buffer(),
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_identity.map(IdentityContractNonceFetcher),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetIdentityBalanceRequest> for IdentityBalance {
    type Request = platform::GetIdentityBalanceRequest;
    type Response = platform::GetIdentityBalanceResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityBalance: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let id = match request.version.ok_or(Error::EmptyVersion)? {
            get_identity_balance_request::Version::V0(v0) => Identifier::from_bytes(&v0.id)
                .map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                }),
        }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) = Drive::verify_identity_balance_for_identity_id(
            supported_grovedb_proof_bytes(proof)?,
            id.into_buffer(),
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_identity, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetIdentitiesBalancesRequest> for IdentityBalances {
    type Request = platform::GetIdentitiesBalancesRequest;
    type Response = platform::GetIdentitiesBalancesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityBalances: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let identities_ids = match request.version.ok_or(Error::EmptyVersion)? {
            get_identities_balances_request::Version::V0(v0) => v0.ids,
        };

        let identity_ids = identities_ids
            .into_iter()
            .map(|identity_bytes| {
                Identifier::from_bytes(&identity_bytes)
                    .map(|identifier| identifier.into_buffer())
                    .map_err(|e| Error::RequestError {
                        error: format!("identities must be all 32 bytes {}", e),
                    })
            })
            .collect::<Result<Vec<[u8; 32]>, Error>>()?;
        let (root_hash, balances) = Drive::verify_identity_balances_for_identity_ids(
            supported_grovedb_proof_bytes(proof)?,
            false,
            &identity_ids,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((Some(balances), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetIdentityBalanceAndRevisionRequest> for IdentityBalanceAndRevision {
    type Request = platform::GetIdentityBalanceAndRevisionRequest;
    type Response = platform::GetIdentityBalanceAndRevisionResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        IdentityBalanceAndRevision: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let id = match request.version.ok_or(Error::EmptyVersion)? {
            get_identity_balance_and_revision_request::Version::V0(v0) => {
                Identifier::from_bytes(&v0.id).map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                })
            }
        }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_identity) =
            Drive::verify_identity_balance_and_revision_for_identity_id(
                supported_grovedb_proof_bytes(proof)?,
                id.into_buffer(),
                false,
                platform_version,
            )
            .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_identity, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetAddressInfoRequest> for AddressInfo {
    type Request = platform::GetAddressInfoRequest;
    type Response = platform::GetAddressInfoResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        AddressInfo: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let address = match request.version.ok_or(Error::EmptyVersion)? {
            get_address_info_request::Version::V0(v0) => PlatformAddress::from_bytes(&v0.address)
                .map_err(|e| Error::RequestError {
                error: format!("invalid address: {}", e),
            })?,
        };

        let (root_hash, maybe_info) = Drive::verify_address_info(
            supported_grovedb_proof_bytes(proof)?,
            &address,
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let info = maybe_info.map(|(nonce, balance)| AddressInfo {
            address,
            nonce,
            balance,
        });

        Ok((info, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetAddressesInfosRequest> for AddressInfos {
    type Request = platform::GetAddressesInfosRequest;
    type Response = platform::GetAddressesInfosResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        AddressInfos: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let addresses_bytes = match request.version.ok_or(Error::EmptyVersion)? {
            get_addresses_infos_request::Version::V0(v0) => v0.addresses,
        };

        let addresses: Vec<PlatformAddress> = addresses_bytes
            .into_iter()
            .map(|bytes| {
                PlatformAddress::from_bytes(&bytes).map_err(|e| Error::RequestError {
                    error: format!("invalid address: {}", e),
                })
            })
            .collect::<Result<_, _>>()?;

        let (root_hash, entries) = Drive::verify_addresses_infos::<
            _,
            Vec<(PlatformAddress, Option<(AddressNonce, Credits)>)>,
        >(
            supported_grovedb_proof_bytes(proof)?,
            addresses.iter(),
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let infos = entries
            .into_iter()
            .map(|(address, maybe_info)| {
                let info = maybe_info.map(|(nonce, balance)| AddressInfo {
                    address,
                    nonce,
                    balance,
                });
                (address, info)
            })
            .collect::<AddressInfos>();

        Ok((Some(infos), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetRecentAddressBalanceChangesRequest> for RecentAddressBalanceChanges {
    type Request = platform::GetRecentAddressBalanceChangesRequest;
    type Response = platform::GetRecentAddressBalanceChangesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        RecentAddressBalanceChanges: 'a,
    {
        use dapi_grpc::platform::v0::get_recent_address_balance_changes_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (start_height, start_height_exclusive) =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_recent_address_balance_changes_request::Version::V0(v0) => {
                    (v0.start_height, v0.start_height_exclusive)
                }
            };

        let limit = Some(100u16); // Same limit as in query handler

        let (root_hash, verified_changes) = if start_height_exclusive {
            Drive::verify_recent_address_balance_changes_after(
                supported_grovedb_proof_bytes(proof)?,
                start_height,
                limit,
                false,
                platform_version,
            )
            .map_drive_error(proof, mtd)?
        } else {
            Drive::verify_recent_address_balance_changes(
                supported_grovedb_proof_bytes(proof)?,
                start_height,
                limit,
                false,
                platform_version,
            )
            .map_drive_error(proof, mtd)?
        };

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let result = RecentAddressBalanceChanges(
            verified_changes
                .into_iter()
                .map(|(block_height, changes)| BlockAddressBalanceChanges {
                    block_height,
                    changes,
                })
                .collect(),
        );

        Ok((Some(result), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetRecentCompactedAddressBalanceChangesRequest>
    for RecentCompactedAddressBalanceChanges
{
    type Request = platform::GetRecentCompactedAddressBalanceChangesRequest;
    type Response = platform::GetRecentCompactedAddressBalanceChangesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        RecentCompactedAddressBalanceChanges: 'a,
    {
        use dapi_grpc::platform::v0::get_recent_compacted_address_balance_changes_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let start_block_height = match request.version.ok_or(Error::EmptyVersion)? {
            get_recent_compacted_address_balance_changes_request::Version::V0(v0) => {
                v0.start_block_height
            }
        };

        // Ensure it is the same limit as in query handler; see
        // packages/rs-drive-abci/src/query/address_funds/recent_compacted_address_balance_changes/v0/mod.rs
        let limit = Some(25u16);

        if platform_version
            .drive
            .methods
            .verify
            .address_funds
            .verify_compacted_address_balance_changes
            == 0
        {
            require_supported_grovedb_proof_bytes(&proof.grovedb_proof)?;
        }

        let (root_hash, verified_changes) = Drive::verify_compacted_address_balance_changes(
            &proof.grovedb_proof,
            start_block_height,
            limit,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_signature(proof, mtd, &root_hash, provider)?;

        let result = RecentCompactedAddressBalanceChanges(
            verified_changes
                .into_iter()
                .map(|(start_block_height, end_block_height, changes)| {
                    CompactedBlockAddressBalanceChanges {
                        start_block_height,
                        end_block_height,
                        changes,
                    }
                })
                .collect(),
        );

        Ok((Some(result), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetAddressesTrunkStateRequest> for GroveTrunkQueryResult {
    type Request = platform::GetAddressesTrunkStateRequest;
    type Response = platform::GetAddressesTrunkStateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        GroveTrunkQueryResult: 'a,
    {
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (root_hash, trunk_result) = Drive::verify_address_funds_trunk_query(
            supported_grovedb_proof_bytes(proof)?,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_signature(proof, mtd, &root_hash, provider)?;

        Ok((Some(trunk_result), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetAddressesTrunkStateRequest> for PlatformAddressTrunkState {
    type Request = platform::GetAddressesTrunkStateRequest;
    type Response = platform::GetAddressesTrunkStateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        PlatformAddressTrunkState: 'a,
    {
        let (result, metadata, proof) = <GroveTrunkQueryResult as FromProof<
            platform::GetAddressesTrunkStateRequest,
        >>::maybe_from_proof_with_metadata(
            request, response, network, platform_version, provider
        )?;

        Ok((result.map(PlatformAddressTrunkState), metadata, proof))
    }
}

impl FromProof<platform::GetDataContractRequest> for DataContract {
    type Request = platform::GetDataContractRequest;
    type Response = platform::GetDataContractResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        DataContract: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let id = match request.version.ok_or(Error::EmptyVersion)? {
            get_data_contract_request::Version::V0(v0) => {
                Identifier::from_bytes(&v0.id).map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                })
            }
        }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_contract) = Drive::verify_contract(
            supported_grovedb_proof_bytes(proof)?,
            None,
            false,
            false,
            id.into_buffer(),
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_contract, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetDataContractRequest> for (DataContract, Vec<u8>) {
    type Request = platform::GetDataContractRequest;
    type Response = platform::GetDataContractResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        DataContract: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let id = match request.version.ok_or(Error::EmptyVersion)? {
            get_data_contract_request::Version::V0(v0) => {
                Identifier::from_bytes(&v0.id).map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                })
            }
        }?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_contract) = Drive::verify_contract_return_serialization(
            supported_grovedb_proof_bytes(proof)?,
            None,
            false,
            false,
            id.into_buffer(),
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((maybe_contract, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetDataContractsRequest> for DataContracts {
    type Request = platform::GetDataContractsRequest;
    type Response = platform::GetDataContractsResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        DataContracts: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let ids = match request.version.ok_or(Error::EmptyVersion)? {
            get_data_contracts_request::Version::V0(v0) => v0.ids,
        };

        let ids = ids
            .iter()
            .map(|id| {
                id.clone().try_into().map_err(|_e| Error::RequestError {
                    error: format!("wrong id size: expected: {}, got: {}", 32, id.len()),
                })
            })
            .collect::<Result<Vec<[u8; 32]>, Error>>()?;

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, contracts) = Drive::verify_contracts(
            supported_grovedb_proof_bytes(proof)?,
            false,
            ids.as_slice(),
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;
        let contracts = contracts
            .into_iter()
            .map(|(k, v)| {
                Identifier::from_bytes(&k).map(|id| (id, v)).map_err(|e| {
                    Error::ResultEncodingError {
                        error: e.to_string(),
                    }
                })
            })
            .collect::<Result<DataContracts, Error>>()?;

        let maybe_contracts = if contracts.is_empty() {
            None
        } else {
            Some(contracts)
        };

        Ok((maybe_contracts, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetDataContractHistoryRequest> for DataContractHistory {
    type Request = platform::GetDataContractHistoryRequest;
    type Response = platform::GetDataContractHistoryResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (id, limit, offset, start_at_ms) = match request.version.ok_or(Error::EmptyVersion)? {
            get_data_contract_history_request::Version::V0(v0) => {
                let id = Identifier::from_bytes(&v0.id).map_err(|e| Error::ProtocolError {
                    error: e.to_string(),
                })?;
                let limit = u32_to_u16_opt(v0.limit.unwrap_or_default())?;
                let offset = u32_to_u16_opt(v0.offset.unwrap_or_default())?;
                let start_at_ms = v0.start_at_ms;
                (id, limit, offset, start_at_ms)
            }
        };

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, maybe_history) = Drive::verify_contract_history(
            supported_grovedb_proof_bytes(proof)?,
            id.into_buffer(),
            start_at_ms,
            limit,
            offset,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_history.map(IndexMap::from_iter),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetDocumentHistoryRequest> for DocumentHistory {
    type Request = platform::GetDocumentHistoryRequest;
    type Response = platform::GetDocumentHistoryResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (contract_id, document_type_name, document_id, limit, offset, start_at_ms) =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_document_history_request::Version::V0(v0) => {
                    let contract_id =
                        Identifier::from_bytes(&v0.data_contract_id).map_err(|e| {
                            Error::ProtocolError {
                                error: e.to_string(),
                            }
                        })?;
                    let document_id = Identifier::from_bytes(&v0.document_id).map_err(|e| {
                        Error::ProtocolError {
                            error: e.to_string(),
                        }
                    })?;
                    let limit = u32_to_u16_opt(v0.limit.unwrap_or_default())?;
                    let offset = u32_to_u16_opt(v0.offset.unwrap_or_default())?;
                    (
                        contract_id,
                        v0.document_type_name,
                        document_id,
                        limit,
                        offset,
                        v0.start_at_ms,
                    )
                }
            };

        let data_contract = provider
            .get_data_contract(&contract_id, platform_version)?
            .ok_or(Error::NotFound)?;
        let document_type = data_contract
            .document_type_for_name(&document_type_name)
            .map_err(|e| Error::ProtocolError {
                error: e.to_string(),
            })?;

        let (root_hash, maybe_history) = Drive::verify_document_history(
            supported_grovedb_proof_bytes(proof)?,
            contract_id.into_buffer(),
            &document_type_name,
            document_type,
            document_id.into_buffer(),
            start_at_ms,
            limit,
            offset,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        // Preserve the distinction between a verified-but-empty history page
        // (e.g. an offset/start_at_ms past the last revision) and an absent
        // result: DocumentHistory carries retrieved values, not proof-of-absence,
        // so a proven empty page is a legitimate `Some(empty)` rather than `None`.
        Ok((
            maybe_history.map(IndexMap::from_iter),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::BroadcastStateTransitionRequest> for StateTransitionProofOutcome {
    type Request = platform::BroadcastStateTransitionRequest;
    type Response = platform::WaitForStateTransitionResultResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let state_transition = StateTransition::deserialize_from_bytes_untrusted(
            &request.state_transition,
        )
        .map_err(|e| Error::ProtocolError {
            error: e.to_string(),
        })?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let block_info = BlockInfo {
            time_ms: mtd.time_ms,
            height: mtd.height,
            core_height: mtd.core_chain_locked_height,
            // Response metadata is not part of the authenticated state ID.
            // Current proof consumers do not require an epoch, so do not
            // propagate an unsigned selector into the verification context.
            epoch: Default::default(),
        };

        let query_platform_version = proof_query_platform_version(mtd)?;

        let contracts_provider_fn = provider.as_contract_lookup_fn(platform_version);

        // Transition families whose proof cannot be bound to execution
        // (balance top-ups, credit transfers/withdrawals, address funds
        // movements, shields, no-history token operations) yield a verified
        // snapshot of the affected keys at the proof's block, tagged
        // `AffectedState` on the `StateTransitionProofOutcome`. The tag is
        // preserved here so SDK callers can enforce their required
        // guarantee: strict waits reject snapshots, snapshot waits treat
        // them as height-pinned state, never as execution evidence.
        let (root_hash, outcome) =
            Drive::verify_state_transition_was_executed_with_proof_for_query_version(
                &state_transition,
                &block_info,
                supported_grovedb_proof_bytes(proof)?,
                &contracts_provider_fn,
                query_platform_version,
                platform_version,
            )
            .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((Some(outcome), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetEpochsInfoRequest> for ExtendedEpochInfo {
    type Request = platform::GetEpochsInfoRequest;
    type Response = platform::GetEpochsInfoResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let epochs = ExtendedEpochInfos::maybe_from_proof_with_metadata(
            request,
            response,
            network,
            platform_version,
            provider,
        )?;

        if let Some(e) = epochs.0 {
            if e.len() != 1 {
                return Err(Error::RequestError {
                    error: format!("expected 1 epoch, got {}", e.len()),
                });
            }
            let epoch = e.into_iter().next().and_then(|v| v.1);
            Ok((epoch, epochs.1, epochs.2))
        } else {
            Ok((None, epochs.1, epochs.2))
        }
    }
}

impl FromProof<platform::GetEpochsInfoRequest> for ExtendedEpochInfos {
    type Request = platform::GetEpochsInfoRequest;
    type Response = platform::GetEpochsInfoResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (start_epoch, count, ascending) = match request.version.ok_or(Error::EmptyVersion)? {
            get_epochs_info_request::Version::V0(v0) => (v0.start_epoch, v0.count, v0.ascending),
        };

        let start_epoch: Option<EpochIndex> = if let Some(epoch) = start_epoch {
            Some(try_u32_to_u16(epoch)?)
        } else {
            None
        };
        if start_epoch.is_none() && !ascending {
            return Err(Error::RequestError {
                error: "proved descending epoch queries require an explicit start epoch"
                    .to_string(),
            });
        }
        // This argument is consulted only for descending queries without an
        // explicit start, which are rejected above. Avoid unsigned metadata.
        let current_epoch: EpochIndex = 0;
        let count = try_u32_to_u16(count)?;

        let (root_hash, epoch_info) = Drive::verify_epoch_infos(
            supported_grovedb_proof_bytes(proof)?,
            current_epoch,
            start_epoch,
            count,
            ascending,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        let epoch_info = epoch_info
            .into_iter()
            .map(|v| {
                #[allow(clippy::infallible_destructuring_match)]
                let info = match &v {
                    ExtendedEpochInfo::V0(i) => i,
                };

                (info.index, Some(v))
            })
            .collect::<ExtendedEpochInfos>();

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((epoch_info.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetFinalizedEpochInfosRequest> for FinalizedEpochInfos {
    type Request = platform::GetFinalizedEpochInfosRequest;
    type Response = platform::GetFinalizedEpochInfosResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (
            start_epoch_index,
            start_epoch_index_included,
            end_epoch_index,
            end_epoch_index_included,
        ) = match request.version.ok_or(Error::EmptyVersion)? {
            get_finalized_epoch_infos_request::Version::V0(v0) => (
                v0.start_epoch_index,
                v0.start_epoch_index_included,
                v0.end_epoch_index,
                v0.end_epoch_index_included,
            ),
        };

        let start_epoch_index: EpochIndex = try_u32_to_u16(start_epoch_index)?;
        let end_epoch_index: EpochIndex = try_u32_to_u16(end_epoch_index)?;

        let (root_hash, epoch_info) = Drive::verify_finalized_epoch_infos(
            supported_grovedb_proof_bytes(proof)?,
            start_epoch_index,
            start_epoch_index_included,
            end_epoch_index,
            end_epoch_index_included,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        let epoch_info = epoch_info
            .into_iter()
            .map(|(epoch_index, finalized_epoch_info)| (epoch_index, Some(finalized_epoch_info)))
            .collect::<FinalizedEpochInfos>();

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((epoch_info.into_option(), mtd.clone(), proof.clone()))
    }
}

fn try_u32_to_u16(i: u32) -> Result<u16, Error> {
    i.try_into()
        .map_err(|e: TryFromIntError| Error::RequestError {
            error: e.to_string(),
        })
}

impl FromProof<GetProtocolVersionUpgradeStateRequest> for ProtocolVersionUpgrades {
    type Request = GetProtocolVersionUpgradeStateRequest;
    type Response = GetProtocolVersionUpgradeStateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (root_hash, objects) =
            Drive::verify_upgrade_state(supported_grovedb_proof_bytes(proof)?, platform_version)
                .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        // Convert objects to a map of Option values
        let response: Self = objects.into_iter().map(|(k, v)| (k, Some(v))).collect();

        Ok((response.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<GetProtocolVersionUpgradeVoteStatusRequest> for MasternodeProtocolVotes {
    type Request = GetProtocolVersionUpgradeVoteStatusRequest;
    type Response = GetProtocolVersionUpgradeVoteStatusResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let request_v0: GetProtocolVersionUpgradeVoteStatusRequestV0 = match request.version {
            Some(get_protocol_version_upgrade_vote_status_request::Version::V0(v0)) => v0,
            None => return Err(Error::EmptyVersion),
        };

        let start_pro_tx_hash: Option<[u8; 32]> =
            if request_v0.start_pro_tx_hash.is_empty() {
                None
            } else {
                Some(request_v0.start_pro_tx_hash[..].try_into().map_err(
                    |e: TryFromSliceError| Error::RequestError {
                        error: e.to_string(),
                    },
                )?)
            };
        let count = try_u32_to_u16(request_v0.count)?;

        let (root_hash, objects) = Drive::verify_upgrade_vote_status(
            supported_grovedb_proof_bytes(proof)?,
            start_pro_tx_hash,
            count,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        if objects.is_empty() {
            return Ok((None, mtd.clone(), proof.clone()));
        }
        let votes: MasternodeProtocolVotes = objects
            .into_iter()
            .map(|(key, value)| {
                ProTxHash::from_slice(&key)
                    .map(|pro_tx_hash| {
                        (
                            pro_tx_hash,
                            Some(MasternodeProtocolVote {
                                pro_tx_hash,
                                voted_version: value,
                            }),
                        )
                    })
                    .map_err(|e| Error::ResultEncodingError {
                        error: e.to_string(),
                    })
            })
            .collect::<Result<MasternodeProtocolVotes, Error>>()?;

        Ok((votes.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<GetPathElementsRequest> for Elements {
    type Request = GetPathElementsRequest;
    type Response = GetPathElementsResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let request_v0: GetPathElementsRequestV0 = match request.version {
            Some(get_path_elements_request::Version::V0(v0)) => v0,
            None => return Err(Error::EmptyVersion),
        };

        let path = request_v0.path;
        let keys = request_v0.keys;

        let (root_hash, objects) = Drive::verify_elements(
            supported_grovedb_proof_bytes(proof)?,
            path,
            keys,
            platform_version,
        )?;
        let elements: Elements = Elements::from_iter(objects);

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((elements.into_option(), mtd.clone(), proof.clone()))
    }
}

impl<'dq, Q> FromProof<Q> for Documents
where
    Q: TryInto<DriveDocumentQuery<'dq>> + Clone + 'dq,
    Q::Error: std::fmt::Display,
{
    type Request = Q;
    type Response = platform::GetDocumentsResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let request: DriveDocumentQuery<'dq> =
            request
                .clone()
                .try_into()
                .map_err(|e: Q::Error| Error::RequestError {
                    error: e.to_string(),
                })?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (root_hash, documents) = request
            .verify_proof(
                document_query_proof_bytes(proof, mtd, platform_version)?,
                platform_version,
            )
            .map_drive_error(proof, mtd)?;

        let documents = documents
            .into_iter()
            .map(|d| (d.id(), Some(d)))
            .collect::<Documents>();

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((documents.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetIdentitiesContractKeysRequest> for IdentitiesContractKeys {
    type Request = platform::GetIdentitiesContractKeysRequest;
    type Response = platform::GetIdentitiesContractKeysResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (identities_ids, contract_id, document_type_name, purposes) =
            match request.version.ok_or(Error::EmptyVersion)? {
                get_identities_contract_keys_request::Version::V0(v0) => {
                    let GetIdentitiesContractKeysRequestV0 {
                        identities_ids,
                        contract_id,
                        document_type_name,
                        purposes,
                        ..
                    } = v0;
                    let identifiers = identities_ids
                        .into_iter()
                        .map(|identity_id_vec| {
                            let identifier = Identifier::from_vec(identity_id_vec)?;
                            Ok(identifier.to_buffer())
                        })
                        .collect::<Result<Vec<[u8; 32]>, platform_value::Error>>()
                        .map_err(|e| Error::ProtocolError {
                            error: e.to_string(),
                        })?;
                    let contract_id = Identifier::from_vec(contract_id)
                        .map_err(|e| Error::ProtocolError {
                            error: e.to_string(),
                        })?
                        .into_buffer();
                    let purposes = purposes
                        .into_iter()
                        .map(|purpose| {
                            Purpose::try_from(purpose).map_err(|e| Error::ProtocolError {
                                error: e.to_string(),
                            })
                        })
                        .collect::<Result<Vec<Purpose>, Error>>()?;
                    (identifiers, contract_id, document_type_name, purposes)
                }
            };

        // Extract content from proof and verify Drive/GroveDB proofs
        let (root_hash, identities_contract_keys) = Drive::verify_identities_contract_keys(
            supported_grovedb_proof_bytes(proof)?,
            identities_ids.as_slice(),
            &contract_id,
            document_type_name,
            purposes,
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        if identities_contract_keys.is_empty() {
            return Ok((None, mtd.clone(), proof.clone()));
        }

        Ok((Some(identities_contract_keys), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetContestedResourcesRequest> for ContestedResources {
    type Request = platform::GetContestedResourcesRequest;
    type Response = platform::GetContestedResourcesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Decode request to get drive query
        let drive_query = VotePollsByDocumentTypeQuery::try_from_request(request)?;
        let resolved_request = drive_query.resolve_with_known_contracts_provider(
            &provider.as_contract_lookup_fn(platform_version),
        )?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;
        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let (root_hash, items) = verify_page_drive_proves(resolved_request.limit, |limit| {
            ResolvedVotePollsByDocumentTypeQuery {
                limit,
                ..resolved_request.clone()
            }
            .verify_contests_proof(grovedb_proof, platform_version)
        })
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let resources: ContestedResources = items.into_iter().map(ContestedResource).collect();

        Ok((resources.into_option(), mtd.clone(), proof.clone()))
    }
}

// rpc getContestedResourceVoteState(GetContestedResourceVoteStateRequest) returns (GetContestedResourceVoteStateResponse);
impl FromProof<platform::GetContestedResourceVoteStateRequest> for Contenders {
    type Request = platform::GetContestedResourceVoteStateRequest;
    type Response = platform::GetContestedResourceVoteStateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Decode request to get drive query
        let drive_query = ContestedDocumentVotePollDriveQuery::try_from_request(request)?;

        // Resolve request to get verify_*_proof
        let contracts_provider = provider.as_contract_lookup_fn(platform_version);
        let resolved_request =
            drive_query.resolve_with_known_contracts_provider(&contracts_provider)?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;
        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let (root_hash, contested_resource_vote_state) =
            verify_page_drive_proves(resolved_request.limit, |limit| {
                ResolvedContestedDocumentVotePollDriveQuery {
                    limit,
                    ..resolved_request.clone()
                }
                .verify_vote_poll_vote_state_proof(grovedb_proof, platform_version)
            })
            .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let contenders = contested_resource_vote_state
            .contenders
            .into_iter()
            .map(|v| (v.identity_id(), v))
            .collect();

        let response = Contenders {
            winner: contested_resource_vote_state.winner,
            contenders,
            abstain_vote_tally: contested_resource_vote_state.abstaining_vote_tally,
            lock_vote_tally: contested_resource_vote_state.locked_vote_tally,
        };
        Ok((response.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<GetContestedResourceVotersForIdentityRequest> for Voters {
    type Request = GetContestedResourceVotersForIdentityRequest;
    type Response = GetContestedResourceVotersForIdentityResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Decode request to get drive query
        let drive_query = ContestedDocumentVotePollVotesDriveQuery::try_from_request(request)?;

        // Parse request to get resolved contract that implements verify_*_proof
        let contracts_provider = provider.as_contract_lookup_fn(platform_version);

        let resolved_request =
            drive_query.resolve_with_known_contracts_provider(&contracts_provider)?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;
        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let (root_hash, voters) = verify_page_drive_proves(resolved_request.limit, |limit| {
            ResolvedContestedDocumentVotePollVotesDriveQuery {
                limit,
                ..resolved_request.clone()
            }
            .verify_vote_poll_votes_proof(grovedb_proof, platform_version)
        })
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        if voters.is_empty() {
            return Ok((None, mtd.clone(), proof.clone()));
        }
        let result: Voters = voters.into_iter().map(Voter::from).collect();

        Ok((result.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetContestedResourceIdentityVotesRequest> for ResourceVotesByIdentity {
    type Request = platform::GetContestedResourceIdentityVotesRequest;
    type Response = platform::GetContestedResourceIdentityVotesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Decode request to get drive query
        let drive_query = ContestedResourceVotesGivenByIdentityQuery::try_from_request(request)?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let contract_provider_fn = provider.as_contract_lookup_fn(platform_version);
        let (root_hash, voters) = verify_page_drive_proves(drive_query.limit, |limit| {
            ContestedResourceVotesGivenByIdentityQuery {
                limit,
                ..drive_query.clone()
            }
            .verify_identity_votes_given_proof::<Vec<_>>(
                grovedb_proof,
                &contract_provider_fn,
                platform_version,
            )
        })
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let response: ResourceVotesByIdentity = voters
            .into_iter()
            .map(|(id, vote)| (id, Some(vote)))
            .collect();

        Ok((response.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetVotePollsByEndDateRequest> for VotePollsGroupedByTimestamp {
    type Request = platform::GetVotePollsByEndDateRequest;
    type Response = platform::GetVotePollsByEndDateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        // Decode request to get drive query
        let drive_query = VotePollsByEndDateDriveQuery::try_from_request(request)?;

        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let (root_hash, vote_polls) = verify_page_drive_proves(drive_query.limit, |limit| {
            VotePollsByEndDateDriveQuery {
                limit,
                ..drive_query.clone()
            }
            .verify_vote_polls_by_end_date_proof::<Vec<(_, _)>>(grovedb_proof, platform_version)
        })
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let response = VotePollsGroupedByTimestamp(vote_polls).sorted(drive_query.order_ascending);

        Ok((response.into_option(), mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetPrefundedSpecializedBalanceRequest> for PrefundedSpecializedBalance {
    type Request = platform::GetPrefundedSpecializedBalanceRequest;
    type Response = platform::GetPrefundedSpecializedBalanceResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let balance_id = match request.version.ok_or(Error::EmptyVersion)? {
            get_prefunded_specialized_balance_request::Version::V0(v0) => {
                Identifier::from_vec(v0.id).map_err(|e| Error::RequestError {
                    error: e.to_string(),
                })?
            }
        };

        let proof = response.proof().or(Err(Error::NoProofInResult))?;

        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (root_hash, balance) = Drive::verify_specialized_balance(
            supported_grovedb_proof_bytes(proof)?,
            balance_id.into_buffer(),
            false,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((balance.map(|v| v.into()), mtd.clone(), proof.clone()))
    }
}

/// The vote poll of the vote a single-vote request asks for.
///
/// A vote is the identity's vote on one vote poll, so the request has to start at that poll,
/// including it.
fn requested_vote_poll_id(
    request: &platform::GetContestedResourceIdentityVotesRequest,
) -> Result<Identifier, Error> {
    match request.version.as_ref().ok_or(Error::EmptyVersion)? {
        get_contested_resource_identity_votes_request::Version::V0(v0) => {
            match &v0.start_at_vote_poll_id_info {
                Some(start) if start.start_poll_identifier_included => {
                    Identifier::from_bytes(&start.start_at_poll_identifier).map_err(|e| {
                        Error::RequestError {
                            error: e.to_string(),
                        }
                    })
                }
                _ => Err(Error::RequestError {
                    error: "a vote request must start at the vote poll of the vote, including it"
                        .to_string(),
                }),
            }
        }
    }
}

impl FromProof<platform::GetContestedResourceIdentityVotesRequest> for Vote {
    type Request = platform::GetContestedResourceIdentityVotesRequest;
    type Response = platform::GetContestedResourceIdentityVotesResponse;

    fn check_request(
        request: &Self::Request,
        _platform_version: &PlatformVersion,
    ) -> Result<(), Error> {
        requested_vote_poll_id(request).map(|_| ())
    }

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request = request.into();
        let vote_poll_id = requested_vote_poll_id(&request)?;

        let (maybe_votes, mtd, proof) = ResourceVotesByIdentity::maybe_from_proof_with_metadata(
            request,
            response,
            network,
            platform_version,
            provider,
        )?;

        // The proved votes are keyed by vote poll id. When the identity has not voted on the
        // requested poll, the proof carries its votes on the polls that follow it in the
        // requested order instead, up to the limit, and none of them is the requested vote.
        let vote = maybe_votes
            .and_then(|mut votes| votes.shift_remove(&vote_poll_id))
            .flatten()
            .map(Vote::ResourceVote);

        Ok((vote, mtd, proof))
    }
}

impl FromProof<platform::GetTotalCreditsInPlatformRequest> for TotalCreditsInPlatform {
    type Request = platform::GetTotalCreditsInPlatformRequest;
    type Response = platform::GetTotalCreditsInPlatformResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let core_subsidy_halving_interval = network.core_subsidy_halving_interval();

        let (root_hash, credits) = Drive::verify_total_credits_in_system(
            supported_grovedb_proof_bytes(proof)?,
            core_subsidy_halving_interval,
            || {
                provider.get_platform_activation_height().map_err(|e| {
                    drive::error::Error::Proof(ProofError::MissingContextRequirement(e.to_string()))
                })
            },
            mtd.core_chain_locked_height,
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            Some(TotalCreditsInPlatform(credits)),
            mtd.clone(),
            proof.clone(),
        ))
    }
}
impl FromProof<platform::GetEvonodesProposedEpochBlocksByIdsRequest> for ProposerBlockCounts {
    type Request = platform::GetEvonodesProposedEpochBlocksByIdsRequest;
    type Response = platform::GetEvonodesProposedEpochBlocksResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (ids, epoch) = match request.version.ok_or(Error::EmptyVersion)? {
            get_evonodes_proposed_epoch_blocks_by_ids_request::Version::V0(v0) => {
                (v0.ids, v0.epoch)
            }
        };

        let epoch_index = match epoch {
            Some(index) => try_u32_to_u16(index)?,
            None => {
                return Err(Error::RequestError {
                    error: "proved proposer queries require an explicit epoch".to_string(),
                })
            }
        };

        let (root_hash, proposer_block_counts) = Drive::verify_epoch_proposers(
            supported_grovedb_proof_bytes(proof)?,
            epoch_index,
            ProposerQueryType::ByIds(ids),
            platform_version,
        )
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            Some(ProposerBlockCounts(proposer_block_counts)),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetEvonodesProposedEpochBlocksByRangeRequest> for ProposerBlockCounts {
    type Request = platform::GetEvonodesProposedEpochBlocksByRangeRequest;
    type Response = platform::GetEvonodesProposedEpochBlocksResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        // Parse response to read proof and metadata
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (epoch, limit, start) = match request.version.ok_or(Error::EmptyVersion)? {
            get_evonodes_proposed_epoch_blocks_by_range_request::Version::V0(v0) => {
                (v0.epoch, v0.limit, v0.start)
            }
        };

        let formatted_start = match start {
            None => None,
            Some(Start::StartAfter(after)) => {
                let id: [u8; 32] = after.try_into().map_err(|_| Error::DriveError {
                    error: "Invalid public key hash length".to_string(),
                })?;
                Some((id, false))
            }
            Some(Start::StartAt(at)) => {
                let id: [u8; 32] = at.try_into().map_err(|_| Error::DriveError {
                    error: "Invalid public key hash length".to_string(),
                })?;
                Some((id, true))
            }
        };

        let epoch_index = match epoch {
            Some(index) => try_u32_to_u16(index)?,
            None => {
                return Err(Error::RequestError {
                    error: "proved proposer queries require an explicit epoch".to_string(),
                })
            }
        };
        let checked_limit = limit.map(try_u32_to_u16).transpose()?;
        let grovedb_proof = supported_grovedb_proof_bytes(proof)?;

        let (root_hash, proposer_block_counts) = verify_page_drive_proves(checked_limit, |limit| {
            Drive::verify_epoch_proposers(
                grovedb_proof,
                epoch_index,
                ProposerQueryType::ByRange(limit, formatted_start),
                platform_version,
            )
        })
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            Some(ProposerBlockCounts(proposer_block_counts)),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

/// Convert u32, if 0 return None, otherwise return Some(u16).
/// Errors when value is out of range.
fn u32_to_u16_opt(i: u32) -> Result<Option<u16>, Error> {
    let i: Option<u16> = if i != 0 {
        let i: u16 = i
            .try_into()
            .map_err(|e: TryFromIntError| Error::RequestError {
                error: format!("value {} out of range: {}", i, e),
            })?;
        Some(i)
    } else {
        None
    };

    Ok(i)
}

// --- Shielded Pool Query Proof Verification ---

/// The optional `token_id` every shielded pool request carries: `None` targets the credit
/// shielded pool, `Some` the pool of that token. The verifier must prove against the same
/// pool the request named, so a malformed id is a request error rather than a silent fallback.
fn shielded_pool_token_id(token_id: Option<Vec<u8>>) -> Result<Option<[u8; 32]>, Error> {
    token_id
        .map(|token_id| {
            token_id
                .try_into()
                .map_err(|token_id: Vec<u8>| Error::RequestError {
                    error: format!("token_id must be 32 bytes, got {}", token_id.len()),
                })
        })
        .transpose()
}

impl FromProof<platform::GetShieldedPoolStateRequest> for ShieldedPoolState {
    type Request = platform::GetShieldedPoolStateRequest;
    type Response = platform::GetShieldedPoolStateResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_shielded_pool_state_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let token_id = match request.version.ok_or(Error::EmptyVersion)? {
            get_shielded_pool_state_request::Version::V0(v0) => {
                shielded_pool_token_id(v0.token_id)?
            }
        };

        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, maybe_balance) = match token_id {
            None => Drive::verify_shielded_pool_state(proof_bytes, false, platform_version),
            Some(token_id) => Drive::verify_token_shielded_pool_state(
                proof_bytes,
                token_id,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_balance.map(ShieldedPoolState),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetShieldedNotesCountRequest> for ShieldedNotesCount {
    type Request = platform::GetShieldedNotesCountRequest;
    type Response = platform::GetShieldedNotesCountResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_shielded_notes_count_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let token_id = match request.version.ok_or(Error::EmptyVersion)? {
            get_shielded_notes_count_request::Version::V0(v0) => {
                shielded_pool_token_id(v0.token_id)?
            }
        };

        // Mirrors `ShieldedPoolState` above; the only difference is the
        // proved element type — `verify_shielded_notes_count` decodes
        // `total_count` out of the `CommitmentTree` element rather than a
        // `SumItem` balance.
        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, maybe_count) = match token_id {
            None => Drive::verify_shielded_notes_count(proof_bytes, false, platform_version),
            Some(token_id) => Drive::verify_token_shielded_pool_notes_count(
                proof_bytes,
                token_id,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_count.map(ShieldedNotesCount),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetShieldedAnchorsRequest> for ShieldedAnchors {
    type Request = platform::GetShieldedAnchorsRequest;
    type Response = platform::GetShieldedAnchorsResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_shielded_anchors_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let token_id = match request.version.ok_or(Error::EmptyVersion)? {
            get_shielded_anchors_request::Version::V0(v0) => shielded_pool_token_id(v0.token_id)?,
        };

        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, anchors) = match token_id {
            None => Drive::verify_shielded_anchors(proof_bytes, false, platform_version),
            Some(token_id) => Drive::verify_token_shielded_pool_anchors(
                proof_bytes,
                token_id,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let result = if anchors.is_empty() {
            None
        } else {
            Some(ShieldedAnchors(anchors))
        };

        Ok((result, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetMostRecentShieldedAnchorRequest> for MostRecentShieldedAnchor {
    type Request = platform::GetMostRecentShieldedAnchorRequest;
    type Response = platform::GetMostRecentShieldedAnchorResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_most_recent_shielded_anchor_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let token_id = match request.version.ok_or(Error::EmptyVersion)? {
            get_most_recent_shielded_anchor_request::Version::V0(v0) => {
                shielded_pool_token_id(v0.token_id)?
            }
        };

        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, maybe_anchor) = match token_id {
            None => Drive::verify_most_recent_shielded_anchor(proof_bytes, false, platform_version),
            Some(token_id) => Drive::verify_most_recent_token_shielded_pool_anchor(
                proof_bytes,
                token_id,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        Ok((
            maybe_anchor.map(MostRecentShieldedAnchor),
            mtd.clone(),
            proof.clone(),
        ))
    }
}

impl FromProof<platform::GetShieldedEncryptedNotesRequest> for ShieldedEncryptedNotes {
    type Request = platform::GetShieldedEncryptedNotesRequest;
    type Response = platform::GetShieldedEncryptedNotesResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_shielded_encrypted_notes_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (start_index, count, token_id) = match request.version.ok_or(Error::EmptyVersion)? {
            get_shielded_encrypted_notes_request::Version::V0(v0) => (
                v0.start_index,
                v0.count,
                shielded_pool_token_id(v0.token_id)?,
            ),
        };

        let max_elements = platform_version
            .drive_abci
            .query
            .shielded_queries
            .max_query_chunks as u32
            * (1u32 << drive::drive::shielded::paths::SHIELDED_NOTES_CHUNK_POWER);

        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, notes, total_count) = match token_id {
            None => Drive::verify_shielded_encrypted_notes(
                proof_bytes,
                start_index,
                count,
                max_elements,
                false,
                platform_version,
            ),
            Some(token_id) => Drive::verify_token_shielded_pool_encrypted_notes(
                proof_bytes,
                token_id,
                start_index,
                count,
                max_elements,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        // `total_count` (the on-chain total note count) is extracted from the
        // same proof, so it is available even when this chunk returned no
        // notes — return the result whenever the proof verified, carrying the
        // count for the sync progress-bar denominator. `None` would only be
        // appropriate if the proof itself were absent, which is handled above.
        let result = Some(ShieldedEncryptedNotes {
            notes: notes
                .into_iter()
                .map(|n| ShieldedEncryptedNote {
                    cmx: n.cmx.to_vec(),
                    nullifier: n.nullifier.to_vec(),
                    cv_net: n.cv_net.to_vec(),
                    encrypted_note: n.encrypted_note.to_vec(),
                })
                .collect(),
            total_count,
        });

        Ok((result, mtd.clone(), proof.clone()))
    }
}

impl FromProof<platform::GetShieldedNullifiersRequest> for ShieldedNullifierStatuses {
    type Request = platform::GetShieldedNullifiersRequest;
    type Response = platform::GetShieldedNullifiersResponse;

    fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
        provider: &'a dyn ContextProvider,
    ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
    where
        Self: Sized + 'a,
    {
        use dapi_grpc::platform::v0::get_shielded_nullifiers_request;

        let request: Self::Request = request.into();
        let response: Self::Response = response.into();
        let proof = response.proof().or(Err(Error::NoProofInResult))?;
        let mtd = response.metadata().or(Err(Error::EmptyResponseMetadata))?;

        let (nullifiers, token_id) = match request.version.ok_or(Error::EmptyVersion)? {
            get_shielded_nullifiers_request::Version::V0(v0) => {
                (v0.nullifiers, shielded_pool_token_id(v0.token_id)?)
            }
        };

        let proof_bytes = supported_grovedb_proof_bytes(proof)?;
        let (root_hash, statuses) = match token_id {
            None => {
                Drive::verify_shielded_nullifiers(proof_bytes, &nullifiers, false, platform_version)
            }
            Some(token_id) => Drive::verify_token_shielded_pool_nullifiers(
                proof_bytes,
                token_id,
                &nullifiers,
                false,
                platform_version,
            ),
        }
        .map_drive_error(proof, mtd)?;

        verify_tenderdash_proof(proof, mtd, &root_hash, provider)?;

        let result = if statuses.is_empty() {
            None
        } else {
            Some(ShieldedNullifierStatuses(
                statuses
                    .into_iter()
                    .map(|(nullifier, is_spent)| {
                        let nullifier: [u8; 32] =
                            nullifier
                                .try_into()
                                .map_err(|_| Error::ResultEncodingError {
                                    error: "nullifier from Drive proof is not 32 bytes".to_string(),
                                })?;
                        Ok(ShieldedNullifierStatus {
                            nullifier,
                            is_spent,
                        })
                    })
                    .collect::<Result<Vec<_>, Error>>()?,
            ))
        };

        Ok((result, mtd.clone(), proof.clone()))
    }
}

/// Determine number of non-None elements
pub trait Length {
    /// Return number of non-None elements in the data structure
    fn count_some(&self) -> usize;
    /// Return number of all elements in the data structure, including None
    fn count(&self) -> usize;
}

impl<T: Length> Length for Option<T> {
    fn count_some(&self) -> usize {
        match self {
            None => 0,
            Some(i) => i.count_some(),
        }
    }
    fn count(&self) -> usize {
        match self {
            None => 0,
            Some(i) => i.count(),
        }
    }
}

impl<T> Length for Vec<Option<T>> {
    fn count_some(&self) -> usize {
        self.iter().filter(|v| v.is_some()).count()
    }

    fn count(&self) -> usize {
        self.len()
    }
}

impl<K, T> Length for Vec<(K, Option<T>)> {
    fn count_some(&self) -> usize {
        self.iter().filter(|(_, v)| v.is_some()).count()
    }

    fn count(&self) -> usize {
        self.len()
    }
}

impl<K, T> Length for BTreeMap<K, Option<T>> {
    fn count_some(&self) -> usize {
        self.values().filter(|v| v.is_some()).count()
    }

    fn count(&self) -> usize {
        self.len()
    }
}

impl<K, T> Length for IndexMap<K, Option<T>> {
    fn count_some(&self) -> usize {
        self.values().filter(|v| v.is_some()).count()
    }

    fn count(&self) -> usize {
        self.len()
    }
}

/// Implement Length trait for a type
///
/// # Arguments
///
/// * `$object`: The type for which to implement Length trait
/// * `$len`: A closure that returns the length of the object; if omitted, defaults to 1
macro_rules! define_length {
    ($object:ty,$some:expr,$counter:expr) => {
        impl Length for $object {
            fn count_some(&self) -> usize {
                #[allow(clippy::redundant_closure_call)]
                $some(self)
            }

            fn count(&self) -> usize {
                #[allow(clippy::redundant_closure_call)]
                $counter(self)
            }
        }
    };
    ($object:ty,$some:expr) => {
        define_length!($object, $some, $some);
    };
    ($object:ty) => {
        define_length!($object, |_| 1, |_| 1);
    };
}

define_length!(DataContract);
define_length!(DataContractHistory, |d: &DataContractHistory| d.len());
define_length!(DocumentHistory, |d: &DocumentHistory| d.len());
define_length!(Document);
define_length!(Identity);
define_length!(IdentityBalance);
define_length!(IdentityBalanceAndRevision);
define_length!(
    IdentitiesContractKeys,
    |x: &IdentitiesContractKeys| x.values().map(|v| v.count_some()).sum(),
    |x: &IdentitiesContractKeys| x.len()
);
define_length!(ContestedResources, |x: &ContestedResources| x.0.len());
define_length!(Contenders, |x: &Contenders| x.contenders.len());
define_length!(Voters, |x: &Voters| x.0.len());
define_length!(
    VotePollsGroupedByTimestamp,
    |x: &VotePollsGroupedByTimestamp| x.0.iter().map(|v| v.1.len()).sum(),
    |x: &VotePollsGroupedByTimestamp| x.0.len()
);

/// Convert a type into an Option
trait IntoOption
where
    Self: Sized,
{
    /// For zero-length data structures, return None, otherwise return Some(self).
    ///
    /// In case of a zero-length data structure, the function returns None.
    /// Otherwise, it returns Some(self), even it all values are None. This is to ensure that proof of absence
    /// preserves the keys that are not present in the data structure.
    fn into_option(self) -> Option<Self>;
}

impl<L: Length> IntoOption for L {
    fn into_option(self) -> Option<Self>
    where
        Self: Sized,
    {
        if self.count() == 0 {
            None
        } else {
            Some(self)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn try_u32_to_u16_succeeds_for_valid_values() {
        assert_eq!(try_u32_to_u16(0).unwrap(), 0u16);
        assert_eq!(try_u32_to_u16(1).unwrap(), 1u16);
        assert_eq!(try_u32_to_u16(42).unwrap(), 42u16);
        assert_eq!(try_u32_to_u16(u16::MAX as u32).unwrap(), u16::MAX);
    }

    #[test]
    fn try_u32_to_u16_errors_on_overflow() {
        // This is the exact attack vector: epoch 65536 would silently truncate
        // to 0 with `as u16`, allowing a malicious node to serve a proof for
        // epoch 0 while claiming the metadata epoch is 65536.
        let result = try_u32_to_u16(65536);
        assert!(
            result.is_err(),
            "epoch 65536 must not silently truncate to 0"
        );

        let result = try_u32_to_u16(u32::MAX);
        assert!(result.is_err(), "epoch u32::MAX must not silently truncate");

        let result = try_u32_to_u16(100_000);
        assert!(result.is_err(), "epoch 100000 must not silently truncate");
    }

    #[test]
    fn u32_to_u16_opt_succeeds_for_valid_values() {
        assert_eq!(u32_to_u16_opt(0).unwrap(), None);
        assert_eq!(u32_to_u16_opt(1).unwrap(), Some(1u16));
        assert_eq!(u32_to_u16_opt(u16::MAX as u32).unwrap(), Some(u16::MAX));
    }

    #[test]
    fn u32_to_u16_opt_errors_on_overflow() {
        let result = u32_to_u16_opt(65536);
        assert!(
            result.is_err(),
            "value 65536 must not silently truncate to 0"
        );

        let result = u32_to_u16_opt(u32::MAX);
        assert!(result.is_err(), "value u32::MAX must not silently truncate");
    }

    // ---------------------------------------------------------------------
    // Length / IntoOption trait tests
    // ---------------------------------------------------------------------

    #[test]
    fn length_vec_option_counts_some_and_total() {
        let v: Vec<Option<u32>> = vec![Some(1), None, Some(2), None, Some(3)];
        assert_eq!(v.count(), 5);
        assert_eq!(v.count_some(), 3);

        let empty: Vec<Option<u32>> = vec![];
        assert_eq!(empty.count(), 0);
        assert_eq!(empty.count_some(), 0);
    }

    #[test]
    fn length_option_of_length_delegates() {
        let inner: Vec<Option<u32>> = vec![Some(1), None];
        let some_inner: Option<Vec<Option<u32>>> = Some(inner);
        assert_eq!(some_inner.count(), 2);
        assert_eq!(some_inner.count_some(), 1);

        let none_inner: Option<Vec<Option<u32>>> = None;
        assert_eq!(none_inner.count(), 0);
        assert_eq!(none_inner.count_some(), 0);
    }

    #[test]
    fn length_vec_of_key_option_pair() {
        let v: Vec<(u8, Option<u32>)> = vec![(1, Some(10)), (2, None), (3, Some(30)), (4, None)];
        assert_eq!(v.count(), 4);
        assert_eq!(v.count_some(), 2);
    }

    #[test]
    fn length_btreemap_of_option() {
        let mut m: BTreeMap<u8, Option<u32>> = BTreeMap::new();
        m.insert(1, Some(10));
        m.insert(2, None);
        m.insert(3, Some(30));
        assert_eq!(m.count(), 3);
        assert_eq!(m.count_some(), 2);
    }

    #[test]
    fn length_indexmap_of_option() {
        let mut m: IndexMap<u8, Option<u32>> = IndexMap::new();
        m.insert(1, Some(10));
        m.insert(2, None);
        m.insert(3, Some(30));
        m.insert(4, None);
        assert_eq!(m.count(), 4);
        assert_eq!(m.count_some(), 2);
    }

    #[test]
    fn into_option_returns_none_for_empty_and_some_for_nonempty() {
        // Empty collection -> None
        let empty: Vec<Option<u32>> = vec![];
        assert!(empty.into_option().is_none());

        // Non-empty, even if all are None -> Some(self)
        let all_none: Vec<Option<u32>> = vec![None, None];
        let wrapped = all_none.into_option();
        assert!(wrapped.is_some());
        assert_eq!(wrapped.unwrap().len(), 2);

        // Non-empty with some values -> Some(self)
        let mixed: Vec<Option<u32>> = vec![Some(1), None];
        assert!(mixed.into_option().is_some());
    }

    #[test]
    fn into_option_for_indexmap() {
        let empty: IndexMap<u8, Option<u32>> = IndexMap::new();
        assert!(empty.into_option().is_none());

        let mut m: IndexMap<u8, Option<u32>> = IndexMap::new();
        m.insert(1, None); // only None value, but count() > 0
        let wrapped = m.into_option();
        assert!(
            wrapped.is_some(),
            "IntoOption must preserve maps that carry absence markers"
        );
    }

    // ---------------------------------------------------------------------
    // parse_key_request_type tests
    // ---------------------------------------------------------------------

    #[test]
    fn parse_key_request_type_missing_outer_request() {
        let err = parse_key_request_type(&None)
            .err()
            .expect("None input must error");
        match err {
            Error::RequestError { error } => {
                assert!(
                    error.contains("missing key request type"),
                    "unexpected error message: {error}"
                );
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn parse_key_request_type_missing_inner_request_field() {
        // Outer Some, inner `request` is None -> second `ok_or` triggers.
        let outer = Some(GrpcKeyType { request: None });
        let err = parse_key_request_type(&outer)
            .err()
            .expect("missing request must error");
        match err {
            Error::RequestError { error } => {
                assert!(
                    error.contains("empty request field"),
                    "unexpected error message: {error}"
                );
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn parse_key_request_type_all_keys_variant() {
        use dapi_grpc::platform::v0::AllKeys;
        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::AllKeys(AllKeys {})),
        });
        let parsed = parse_key_request_type(&outer).unwrap();
        assert!(matches!(parsed, KeyRequestType::AllKeys));
    }

    #[test]
    fn parse_key_request_type_specific_keys_variant() {
        use dapi_grpc::platform::v0::SpecificKeys;
        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SpecificKeys(SpecificKeys {
                key_ids: vec![1, 2, 3],
            })),
        });
        let parsed = parse_key_request_type(&outer).unwrap();
        match parsed {
            KeyRequestType::SpecificKeys(ids) => assert_eq!(ids, vec![1, 2, 3]),
            _ => panic!("expected SpecificKeys variant"),
        }
    }

    #[test]
    fn parse_key_request_type_search_key_rejects_invalid_kind() {
        use dapi_grpc::platform::v0::{SearchKey, SecurityLevelMap};
        let mut sec_map: std::collections::HashMap<u32, i32> = std::collections::HashMap::new();
        // 99 is not a valid GrpcKeyKind, must produce RequestError
        sec_map.insert(0, 99);

        let mut purpose_map = std::collections::HashMap::new();
        purpose_map.insert(
            0u32,
            SecurityLevelMap {
                security_level_map: sec_map,
            },
        );

        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SearchKey(SearchKey {
                purpose_map,
            })),
        });

        let err = parse_key_request_type(&outer)
            .err()
            .expect("bad key kind must error");
        match err {
            Error::RequestError { error } => assert!(
                error.contains("missing requested key type"),
                "unexpected error: {error}"
            ),
            other => panic!("expected RequestError for bad key kind, got: {other:?}"),
        }
    }

    #[test]
    fn parse_key_request_type_search_key_accepts_valid_kinds() {
        use dapi_grpc::platform::v0::{SearchKey, SecurityLevelMap};
        let mut sec_map: std::collections::HashMap<u32, i32> = std::collections::HashMap::new();
        sec_map.insert(0, GrpcKeyKind::CurrentKeyOfKindRequest as i32);
        sec_map.insert(1, GrpcKeyKind::AllKeysOfKindRequest as i32);

        let mut purpose_map = std::collections::HashMap::new();
        purpose_map.insert(
            0u32,
            SecurityLevelMap {
                security_level_map: sec_map,
            },
        );

        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SearchKey(SearchKey {
                purpose_map,
            })),
        });

        let parsed = parse_key_request_type(&outer).unwrap();
        match parsed {
            KeyRequestType::SearchKey(purposes) => {
                let inner = purposes.get(&0u8).expect("purpose 0 parsed");
                assert_eq!(inner.len(), 2);
                assert!(matches!(
                    inner.get(&0u8),
                    Some(KeyKindRequestType::CurrentKeyOfKindRequest)
                ));
                assert!(matches!(
                    inner.get(&1u8),
                    Some(KeyKindRequestType::AllKeysOfKindRequest)
                ));
            }
            _ => panic!("expected SearchKey variant"),
        }
    }

    // ---------------------------------------------------------------------
    // FromProof error-path tests
    //
    // These tests verify that response/request decoding errors fire
    // *before* any cryptographic proof verification is attempted, so we
    // don't need a real quorum or GroveDB proof to exercise them.
    // ---------------------------------------------------------------------

    /// A ContextProvider that must never be called during these tests —
    /// if it is, the test has reached the cryptographic-verification stage
    /// incorrectly, which is itself a meaningful failure.
    struct UnreachableContextProvider;

    impl dash_context_provider::ContextProvider for UnreachableContextProvider {
        fn get_data_contract(
            &self,
            _id: &dpp::prelude::Identifier,
            _platform_version: &PlatformVersion,
        ) -> Result<Option<std::sync::Arc<DataContract>>, dash_context_provider::ContextProviderError>
        {
            panic!("context provider should not be called on decode-error test")
        }

        fn get_token_configuration(
            &self,
            _token_id: &dpp::prelude::Identifier,
        ) -> Result<
            Option<dpp::data_contract::TokenConfiguration>,
            dash_context_provider::ContextProviderError,
        > {
            panic!("context provider should not be called on decode-error test")
        }

        fn get_quorum_public_key(
            &self,
            _quorum_type: u32,
            _quorum_hash: [u8; 32],
            _core_chain_locked_height: u32,
        ) -> Result<[u8; 48], dash_context_provider::ContextProviderError> {
            panic!("context provider should not be called on decode-error test")
        }

        fn get_platform_activation_height(
            &self,
        ) -> Result<dpp::prelude::CoreBlockHeight, dash_context_provider::ContextProviderError>
        {
            panic!("context provider should not be called on decode-error test")
        }
    }

    fn unreachable_provider() -> UnreachableContextProvider {
        UnreachableContextProvider
    }

    fn default_platform_version() -> &'static PlatformVersion {
        PlatformVersion::latest()
    }

    struct NoDataContractProvider;

    impl dash_context_provider::ContextProvider for NoDataContractProvider {
        fn get_data_contract(
            &self,
            _id: &dpp::prelude::Identifier,
            _platform_version: &PlatformVersion,
        ) -> Result<Option<std::sync::Arc<DataContract>>, dash_context_provider::ContextProviderError>
        {
            Ok(None)
        }

        fn get_token_configuration(
            &self,
            _token_id: &dpp::prelude::Identifier,
        ) -> Result<
            Option<dpp::data_contract::TokenConfiguration>,
            dash_context_provider::ContextProviderError,
        > {
            panic!("token configuration should not be requested")
        }

        fn get_quorum_public_key(
            &self,
            _quorum_type: u32,
            _quorum_hash: [u8; 32],
            _core_chain_locked_height: u32,
        ) -> Result<[u8; 48], dash_context_provider::ContextProviderError> {
            panic!("quorum public key should not be requested")
        }

        fn get_platform_activation_height(
            &self,
        ) -> Result<dpp::prelude::CoreBlockHeight, dash_context_provider::ContextProviderError>
        {
            panic!("platform activation height should not be requested")
        }
    }

    struct StaticDataContractProvider {
        data_contract: std::sync::Arc<DataContract>,
    }

    impl dash_context_provider::ContextProvider for StaticDataContractProvider {
        fn get_data_contract(
            &self,
            id: &dpp::prelude::Identifier,
            _platform_version: &PlatformVersion,
        ) -> Result<Option<std::sync::Arc<DataContract>>, dash_context_provider::ContextProviderError>
        {
            if self.data_contract.id() == *id {
                Ok(Some(self.data_contract.clone()))
            } else {
                Ok(None)
            }
        }

        fn get_token_configuration(
            &self,
            _token_id: &dpp::prelude::Identifier,
        ) -> Result<
            Option<dpp::data_contract::TokenConfiguration>,
            dash_context_provider::ContextProviderError,
        > {
            panic!("token configuration should not be requested")
        }

        fn get_quorum_public_key(
            &self,
            _quorum_type: u32,
            _quorum_hash: [u8; 32],
            _core_chain_locked_height: u32,
        ) -> Result<[u8; 48], dash_context_provider::ContextProviderError> {
            panic!("quorum public key should not be requested")
        }

        fn get_platform_activation_height(
            &self,
        ) -> Result<dpp::prelude::CoreBlockHeight, dash_context_provider::ContextProviderError>
        {
            panic!("platform activation height should not be requested")
        }
    }

    /// Build a fully-populated `GetIdentityResponse` shell so that
    /// `response.proof()` and `response.metadata()` both succeed. The
    /// enclosed proof is empty, so any real verification would fail — but
    /// these tests stop before that point.
    fn identity_response_with_proof_and_metadata() -> platform::GetIdentityResponse {
        use platform::get_identity_response::{
            get_identity_response_v0::Result as V0Result, GetIdentityResponseV0, Version,
        };
        platform::GetIdentityResponse {
            version: Some(Version::V0(GetIdentityResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        }
    }

    fn document_history_response_with_proof_and_metadata() -> platform::GetDocumentHistoryResponse {
        use platform::get_document_history_response::{
            get_document_history_response_v0::Result as V0Result, GetDocumentHistoryResponseV0,
            Version,
        };
        platform::GetDocumentHistoryResponse {
            version: Some(Version::V0(GetDocumentHistoryResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        }
    }

    fn document_history_request(
        data_contract_id: Vec<u8>,
        document_type_name: &str,
        document_id: Vec<u8>,
        limit: Option<u32>,
        offset: Option<u32>,
    ) -> platform::GetDocumentHistoryRequest {
        use dapi_grpc::platform::v0::get_document_history_request::GetDocumentHistoryRequestV0;
        GetDocumentHistoryRequestV0 {
            data_contract_id,
            document_type_name: document_type_name.to_string(),
            document_id,
            limit,
            offset,
            start_at_ms: 0,
            prove: true,
        }
        .into()
    }

    fn document_history_error(
        request: platform::GetDocumentHistoryRequest,
        response: platform::GetDocumentHistoryResponse,
        provider: &dyn ContextProvider,
    ) -> Error {
        <DocumentHistory as FromProof<
            platform::GetDocumentHistoryRequest,
        >>::maybe_from_proof_with_metadata(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            provider,
        )
        .unwrap_err()
    }

    #[test]
    fn identity_from_proof_no_proof_when_response_empty() {
        // Default response has `version: None` -> response.proof() errors
        // -> mapped to NoProofInResult.
        let request = platform::GetIdentityRequest::default();
        let response = platform::GetIdentityResponse::default();

        let provider = unreachable_provider();
        let err = <Identity as FromProof<platform::GetIdentityRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();

        assert!(
            matches!(err, Error::NoProofInResult),
            "expected NoProofInResult, got: {err:?}"
        );
    }

    #[test]
    fn identity_from_proof_empty_metadata_when_metadata_missing() {
        use platform::get_identity_response::{
            get_identity_response_v0::Result as V0Result, GetIdentityResponseV0, Version,
        };
        // Response has a Proof but no metadata -> EmptyResponseMetadata.
        let response = platform::GetIdentityResponse {
            version: Some(Version::V0(GetIdentityResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: None,
            })),
        };
        let request = platform::GetIdentityRequest::default();
        let provider = unreachable_provider();
        let err = <Identity as FromProof<platform::GetIdentityRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyResponseMetadata), "got: {err:?}");
    }

    #[test]
    fn identity_from_proof_empty_version_when_request_has_no_version() {
        // Valid response, but request.version is None -> EmptyVersion.
        let response = identity_response_with_proof_and_metadata();
        let request = platform::GetIdentityRequest { version: None };
        let provider = unreachable_provider();
        let err = <Identity as FromProof<platform::GetIdentityRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn identity_from_proof_protocol_error_on_bad_id_length() {
        use dapi_grpc::platform::v0::get_identity_request::GetIdentityRequestV0;
        // id must be 32 bytes; anything else fails Identifier::from_bytes.
        let request: platform::GetIdentityRequest = GetIdentityRequestV0 {
            id: vec![0u8; 8],
            prove: true,
        }
        .into();
        let response = identity_response_with_proof_and_metadata();
        let provider = unreachable_provider();
        let err = <Identity as FromProof<platform::GetIdentityRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(
            matches!(err, Error::ProtocolError { .. }),
            "expected ProtocolError on bad id length, got: {err:?}"
        );
    }

    /// A minimal `FromProof` impl whose `maybe_from_proof_with_metadata`
    /// returns `Ok((None, ..))`, isolating the `from_proof` wrapper's
    /// `None -> Error::NotFound` mapping from the decode/verify pipeline.
    #[derive(Debug)]
    struct MissingFromProof;

    impl FromProof<()> for MissingFromProof {
        type Request = ();
        type Response = ();

        fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
            _request: I,
            _response: O,
            _network: Network,
            _platform_version: &PlatformVersion,
            _provider: &'a dyn ContextProvider,
        ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
        where
            Self: Sized + 'a,
        {
            Ok((None, ResponseMetadata::default(), Proof::default()))
        }
    }

    #[test]
    fn from_proof_maps_none_to_not_found() {
        // `from_proof` (vs `maybe_from_proof`) is expected to map `Ok(None)`
        // to `Error::NotFound`. Verify that wrapper behavior directly rather
        // than conflating it with decode-error propagation.
        let provider = unreachable_provider();
        let err = <MissingFromProof as FromProof<()>>::from_proof(
            (),
            (),
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(
            matches!(err, Error::NotFound),
            "expected NotFound when maybe_from_proof returns None, got: {err:?}"
        );
    }

    #[test]
    fn identity_by_public_key_hash_invalid_length_yields_drive_error() {
        use dapi_grpc::platform::v0::get_identity_by_public_key_hash_request::GetIdentityByPublicKeyHashRequestV0;

        // public_key_hash must be exactly 20 bytes; 10 bytes fails.
        let request: platform::GetIdentityByPublicKeyHashRequest =
            GetIdentityByPublicKeyHashRequestV0 {
                public_key_hash: vec![0u8; 10],
                prove: true,
            }
            .into();

        // Build a response that succeeds on proof/metadata lookups.
        use platform::get_identity_by_public_key_hash_response::{
            get_identity_by_public_key_hash_response_v0::Result as V0Result,
            GetIdentityByPublicKeyHashResponseV0, Version,
        };
        let response = platform::GetIdentityByPublicKeyHashResponse {
            version: Some(Version::V0(GetIdentityByPublicKeyHashResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };

        let provider = unreachable_provider();
        let err =
            <Identity as FromProof<platform::GetIdentityByPublicKeyHashRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();

        match err {
            Error::DriveError { error } => {
                assert!(
                    error.contains("Invalid public key hash length"),
                    "unexpected error body: {error}"
                );
            }
            other => panic!("expected DriveError, got: {other:?}"),
        }
    }

    /// A proved request of either version, for a hash and cursor of any length.
    fn non_unique_request(
        version: u8,
        public_key_hash: Vec<u8>,
        start_after: Option<Vec<u8>>,
    ) -> platform::GetIdentityByNonUniquePublicKeyHashRequest {
        use platform::get_identity_by_non_unique_public_key_hash_request::{
            GetIdentityByNonUniquePublicKeyHashRequestV0,
            GetIdentityByNonUniquePublicKeyHashRequestV1, Version,
        };
        platform::GetIdentityByNonUniquePublicKeyHashRequest {
            version: Some(match version {
                0 => Version::V0(GetIdentityByNonUniquePublicKeyHashRequestV0 {
                    public_key_hash,
                    start_after,
                    prove: true,
                }),
                _ => Version::V1(GetIdentityByNonUniquePublicKeyHashRequestV1 {
                    public_key_hash,
                    start_after,
                    prove: true,
                }),
            }),
        }
    }

    /// A proved answer of either version whose signed proof is `proof`; a V0 answer
    /// carries it as the index proof, without an identity proof.
    fn non_unique_response(
        version: u8,
        proof: Proof,
        metadata: ResponseMetadata,
    ) -> platform::GetIdentityByNonUniquePublicKeyHashResponse {
        use platform::get_identity_by_non_unique_public_key_hash_response::{
            get_identity_by_non_unique_public_key_hash_response_v0::IdentityProvedResponse,
            GetIdentityByNonUniquePublicKeyHashResponseV0,
            GetIdentityByNonUniquePublicKeyHashResponseV1,
        };
        platform::GetIdentityByNonUniquePublicKeyHashResponse {
            version: Some(match version {
                0 => NonUniqueLookupVersion::V0(GetIdentityByNonUniquePublicKeyHashResponseV0 {
                    result: Some(NonUniqueLookupV0Result::Proof(IdentityProvedResponse {
                        grovedb_identity_public_key_hash_proof: Some(proof),
                        identity_proof_bytes: None,
                    })),
                    metadata: Some(metadata),
                }),
                _ => NonUniqueLookupVersion::V1(GetIdentityByNonUniquePublicKeyHashResponseV1 {
                    result: Some(NonUniqueLookupV1Result::Proof(proof)),
                    metadata: Some(metadata),
                }),
            }),
        }
    }

    fn non_unique_lookup_error(
        request: platform::GetIdentityByNonUniquePublicKeyHashRequest,
        response: platform::GetIdentityByNonUniquePublicKeyHashResponse,
    ) -> Error {
        <Identity as FromProof<platform::GetIdentityByNonUniquePublicKeyHashRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &unreachable_provider(),
        )
        .unwrap_err()
    }

    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_bad_key_hash_length() {
        for version in [0, 1] {
            // A proved answer gets past the response shape check to the request validation.
            let err = non_unique_lookup_error(
                non_unique_request(version, vec![0u8; 3], None),
                non_unique_response(version, Proof::default(), ResponseMetadata::default()),
            );
            assert!(
                matches!(&err, Error::RequestError { error } if error.contains("Invalid public key hash length")),
                "V{version}: {err:?}"
            );
        }
    }

    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_bad_start_after_length() {
        for version in [0, 1] {
            let err = non_unique_lookup_error(
                non_unique_request(version, vec![0u8; 20], Some(vec![0u8; 10])),
                non_unique_response(version, Proof::default(), ResponseMetadata::default()),
            );
            assert!(
                matches!(&err, Error::RequestError { error } if error.contains("Invalid start_after length")),
                "V{version}: {err:?}"
            );
        }
    }

    /// The request version chooses the proof shape. An answer in the other version is
    /// refused before any proof is read, even when its proof would verify.
    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_the_other_response_version() {
        for (request_version, response_version) in [(0, 1), (1, 0)] {
            let err = non_unique_lookup_error(
                non_unique_request(request_version, vec![0u8; 20], None),
                non_unique_response(
                    response_version,
                    Proof::default(),
                    ResponseMetadata::default(),
                ),
            );
            assert!(
                matches!(&err, Error::ResponseDecodeError { error } if error.contains("does not match request version")),
                "V{request_version} request, V{response_version} response: {err:?}"
            );
        }
    }

    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_v0_complete_proof() {
        for version in [0, 1] {
            let proof = bincode::encode_to_vec(0u32, bincode::config::standard().with_big_endian())
                .expect("V0 envelope discriminant");
            let err = non_unique_lookup_error(
                non_unique_request(version, vec![0u8; 20], None),
                non_unique_response(
                    version,
                    Proof {
                        grovedb_proof: proof,
                        ..Proof::default()
                    },
                    ResponseMetadata {
                        protocol_version: PlatformVersion::latest().protocol_version,
                        ..ResponseMetadata::default()
                    },
                ),
            );
            assert!(
                matches!(
                    err,
                    Error::UnsupportedGroveDBProofVersion { version: 0, .. }
                ),
                "V{version}: {err:?}"
            );
        }
    }

    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_malformed_two_proof_answer() {
        use dapi_grpc::Message;
        // Raw result field 2 decodes as the two-proof answer.
        let mut response = platform::GetIdentityByNonUniquePublicKeyHashResponse::decode(
            &[0x0a, 0x06, 0x12, 0x04, 0x0a, 0x02, 0x0a, 0x00][..],
        )
        .expect("V0 fields decode");
        let Some(NonUniqueLookupVersion::V0(v0)) = &mut response.version else {
            panic!("v0")
        };
        let Some(NonUniqueLookupV0Result::Proof(proved)) = &mut v0.result else {
            panic!("field 2 is the two-proof answer")
        };
        // A supported envelope over garbage, signed as protocol 13: the answer passes the
        // version and envelope checks, so the two-proof verifier itself must refuse it.
        proved
            .grovedb_identity_public_key_hash_proof
            .as_mut()
            .expect("index proof")
            .grovedb_proof = vec![0x01, 0xff, 0xff];
        v0.metadata = Some(ResponseMetadata {
            protocol_version: 13,
            ..Default::default()
        });
        let err = non_unique_lookup_error(non_unique_request(0, vec![0; 20], None), response);
        assert!(matches!(err, Error::GroveDBError { .. }), "{err}");
    }

    #[test]
    fn identity_by_non_unique_public_key_hash_rejects_two_proof_answer_without_index_proof() {
        use platform::get_identity_by_non_unique_public_key_hash_response::get_identity_by_non_unique_public_key_hash_response_v0::IdentityProvedResponse;
        use platform::get_identity_by_non_unique_public_key_hash_response::GetIdentityByNonUniquePublicKeyHashResponseV0;
        // The index proof carries the signature; identity bytes alone prove nothing.
        let response = platform::GetIdentityByNonUniquePublicKeyHashResponse {
            version: Some(NonUniqueLookupVersion::V0(
                GetIdentityByNonUniquePublicKeyHashResponseV0 {
                    result: Some(NonUniqueLookupV0Result::Proof(IdentityProvedResponse {
                        grovedb_identity_public_key_hash_proof: None,
                        identity_proof_bytes: Some(vec![0x01]),
                    })),
                    metadata: Some(ResponseMetadata {
                        protocol_version: 13,
                        ..Default::default()
                    }),
                },
            )),
        };
        let err = non_unique_lookup_error(non_unique_request(0, vec![0; 20], None), response);
        assert!(matches!(err, Error::NoProofInResult), "{err}");
    }

    #[test]
    fn identity_by_non_unique_response_with_no_result_yields_no_proof() {
        use platform::get_identity_by_non_unique_public_key_hash_response::{
            GetIdentityByNonUniquePublicKeyHashResponseV0,
            GetIdentityByNonUniquePublicKeyHashResponseV1,
        };
        for version in [0, 1] {
            let response = platform::GetIdentityByNonUniquePublicKeyHashResponse {
                version: Some(match version {
                    0 => {
                        NonUniqueLookupVersion::V0(GetIdentityByNonUniquePublicKeyHashResponseV0 {
                            result: None,
                            metadata: None,
                        })
                    }
                    _ => {
                        NonUniqueLookupVersion::V1(GetIdentityByNonUniquePublicKeyHashResponseV1 {
                            result: None,
                            metadata: None,
                        })
                    }
                }),
            };
            let err =
                non_unique_lookup_error(non_unique_request(version, vec![0u8; 20], None), response);
            assert!(matches!(err, Error::NoProofInResult), "V{version}: {err:?}");
        }
    }

    #[test]
    fn identity_by_non_unique_proved_response_without_metadata_is_refused() {
        for version in [0, 1] {
            let mut response =
                non_unique_response(version, Proof::default(), ResponseMetadata::default());
            match &mut response.version {
                Some(NonUniqueLookupVersion::V0(v0)) => v0.metadata = None,
                Some(NonUniqueLookupVersion::V1(v1)) => v1.metadata = None,
                None => panic!("version"),
            }
            let err =
                non_unique_lookup_error(non_unique_request(version, vec![0u8; 20], None), response);
            assert!(
                matches!(err, Error::EmptyResponseMetadata),
                "V{version}: {err:?}"
            );
        }
    }

    #[test]
    fn identity_by_non_unique_request_without_version_is_refused() {
        for version in [0, 1] {
            let err = non_unique_lookup_error(
                platform::GetIdentityByNonUniquePublicKeyHashRequest { version: None },
                non_unique_response(version, Proof::default(), ResponseMetadata::default()),
            );
            assert!(matches!(err, Error::EmptyVersion), "V{version}: {err:?}");
        }
    }

    #[test]
    fn identity_by_non_unique_response_with_no_version_yields_no_proof() {
        for version in [0, 1] {
            let err = non_unique_lookup_error(
                non_unique_request(version, vec![0u8; 20], None),
                platform::GetIdentityByNonUniquePublicKeyHashResponse { version: None },
            );
            assert!(matches!(err, Error::NoProofInResult), "V{version}: {err:?}");
        }
    }

    #[test]
    fn identities_balances_rejects_non_32_byte_id() {
        use dapi_grpc::platform::v0::get_identities_balances_request::GetIdentitiesBalancesRequestV0;
        use platform::get_identities_balances_response::{
            get_identities_balances_response_v0::Result as V0Result,
            GetIdentitiesBalancesResponseV0, Version,
        };

        let response = platform::GetIdentitiesBalancesResponse {
            version: Some(Version::V0(GetIdentitiesBalancesResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };

        let request: platform::GetIdentitiesBalancesRequest = GetIdentitiesBalancesRequestV0 {
            ids: vec![vec![0u8; 10]], // wrong length
            prove: true,
        }
        .into();

        let provider = unreachable_provider();
        let err =
            <IdentityBalances as FromProof<platform::GetIdentitiesBalancesRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        match err {
            Error::RequestError { error } => {
                assert!(error.contains("all 32 bytes"), "got: {error}");
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn data_contracts_rejects_wrong_size_id() {
        use dapi_grpc::platform::v0::get_data_contracts_request::GetDataContractsRequestV0;
        use platform::get_data_contracts_response::{
            get_data_contracts_response_v0::Result as V0Result, GetDataContractsResponseV0, Version,
        };

        let response = platform::GetDataContractsResponse {
            version: Some(Version::V0(GetDataContractsResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetDataContractsRequest = GetDataContractsRequestV0 {
            ids: vec![vec![0u8; 20]], // must be 32 bytes
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <DataContracts as FromProof<platform::GetDataContractsRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        match err {
            Error::RequestError { error } => {
                assert!(error.contains("wrong id size"), "got: {error}");
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn upgrade_vote_status_rejects_bad_start_pro_tx_hash_length() {
        use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_request::GetProtocolVersionUpgradeVoteStatusRequestV0;
        use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_response::{
            get_protocol_version_upgrade_vote_status_response_v0::Result as V0Result,
            GetProtocolVersionUpgradeVoteStatusResponseV0, Version,
        };

        let response = GetProtocolVersionUpgradeVoteStatusResponse {
            version: Some(Version::V0(GetProtocolVersionUpgradeVoteStatusResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        // start_pro_tx_hash must be 32 bytes if non-empty.
        let request: GetProtocolVersionUpgradeVoteStatusRequest =
            GetProtocolVersionUpgradeVoteStatusRequestV0 {
                start_pro_tx_hash: vec![0u8; 5],
                count: 10,
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <MasternodeProtocolVotes as FromProof<
            GetProtocolVersionUpgradeVoteStatusRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        match err {
            Error::RequestError { .. } => {}
            other => panic!("expected RequestError for bad pro_tx_hash length, got: {other:?}"),
        }
    }

    #[test]
    fn upgrade_vote_status_empty_version_on_request_none() {
        use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_response::{
            get_protocol_version_upgrade_vote_status_response_v0::Result as V0Result,
            GetProtocolVersionUpgradeVoteStatusResponseV0, Version,
        };
        let response = GetProtocolVersionUpgradeVoteStatusResponse {
            version: Some(Version::V0(GetProtocolVersionUpgradeVoteStatusResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = GetProtocolVersionUpgradeVoteStatusRequest { version: None };
        let provider = unreachable_provider();
        let err = <MasternodeProtocolVotes as FromProof<
            GetProtocolVersionUpgradeVoteStatusRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn path_elements_no_proof_without_response() {
        let request = GetPathElementsRequest::default();
        let response = GetPathElementsResponse::default();
        let provider = unreachable_provider();
        let err = <Elements as FromProof<GetPathElementsRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn prefunded_balance_rejects_bad_id_length() {
        use dapi_grpc::platform::v0::get_prefunded_specialized_balance_request::GetPrefundedSpecializedBalanceRequestV0;
        use platform::get_prefunded_specialized_balance_response::{
            get_prefunded_specialized_balance_response_v0::Result as V0Result,
            GetPrefundedSpecializedBalanceResponseV0, Version,
        };
        let response = platform::GetPrefundedSpecializedBalanceResponse {
            version: Some(Version::V0(GetPrefundedSpecializedBalanceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetPrefundedSpecializedBalanceRequest =
            GetPrefundedSpecializedBalanceRequestV0 {
                id: vec![0u8; 3], // must be 32
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <PrefundedSpecializedBalance as FromProof<
            platform::GetPrefundedSpecializedBalanceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn epochs_info_rejects_overflowing_start_epoch() {
        use dapi_grpc::platform::v0::get_epochs_info_request::GetEpochsInfoRequestV0;
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata {
                    epoch: 10,
                    ..Default::default()
                }),
            })),
        };
        // start_epoch > u16::MAX triggers try_u32_to_u16 error.
        let request = platform::GetEpochsInfoRequest {
            version: Some(platform::get_epochs_info_request::Version::V0(
                GetEpochsInfoRequestV0 {
                    start_epoch: Some(100_000),
                    count: 1,
                    ascending: true,
                    prove: true,
                },
            )),
        };
        let provider = unreachable_provider();
        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn broadcast_state_transition_rejects_garbage_payload() {
        // Cannot deserialize random bytes into a StateTransition, so we hit
        // the ProtocolError branch before any proof work happens.
        let request = platform::BroadcastStateTransitionRequest {
            state_transition: vec![0xFFu8; 16], // nonsense bytes
        };
        // Response structure only needs to have a valid proof field since
        // deserialize happens after proof extraction.
        use platform::wait_for_state_transition_result_response::{
            wait_for_state_transition_result_response_v0::Result as V0Result, Version,
            WaitForStateTransitionResultResponseV0,
        };
        let response = platform::WaitForStateTransitionResultResponse {
            version: Some(Version::V0(WaitForStateTransitionResultResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let provider = unreachable_provider();
        let err = <StateTransitionProofOutcome as FromProof<
            platform::BroadcastStateTransitionRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(
            matches!(err, Error::ProtocolError { .. }),
            "expected ProtocolError from StateTransition decode, got: {err:?}"
        );
    }

    // ---------------------------------------------------------------------
    // Additional coverage: numeric helpers
    // ---------------------------------------------------------------------

    #[test]
    fn u32_to_u16_opt_zero_maps_to_none() {
        // zero -> None (not Some(0)): guards against accidentally treating
        // "unset" as "limit 0".
        let parsed = u32_to_u16_opt(0).unwrap();
        assert!(parsed.is_none(), "value 0 must decode to None");
    }

    #[test]
    fn u32_to_u16_opt_at_boundary() {
        let parsed = u32_to_u16_opt(u16::MAX as u32).unwrap();
        assert_eq!(parsed, Some(u16::MAX));
    }

    #[test]
    fn u32_to_u16_opt_error_just_above_boundary() {
        // u16::MAX + 1 is the minimal out-of-range value.
        let err = u32_to_u16_opt((u16::MAX as u32) + 1).unwrap_err();
        match err {
            Error::RequestError { error } => {
                assert!(error.contains("out of range"), "got: {error}");
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn try_u32_to_u16_at_boundary_plus_one() {
        // u16::MAX is ok; u16::MAX+1 is not.
        assert!(try_u32_to_u16(u16::MAX as u32).is_ok());
        assert!(try_u32_to_u16((u16::MAX as u32) + 1).is_err());
    }

    // ---------------------------------------------------------------------
    // Additional coverage: Length / IntoOption edge cases
    // ---------------------------------------------------------------------

    #[test]
    fn length_option_of_length_none_counts_zero() {
        let none_opt: Option<Vec<Option<u32>>> = None;
        assert_eq!(none_opt.count(), 0);
        assert_eq!(none_opt.count_some(), 0);
    }

    #[test]
    fn length_vec_of_key_option_pair_only_none_values() {
        let v: Vec<(u8, Option<u32>)> = vec![(1, None), (2, None)];
        assert_eq!(v.count(), 2);
        assert_eq!(
            v.count_some(),
            0,
            "count_some must only count entries whose value is Some"
        );
    }

    #[test]
    fn length_btreemap_only_none_values() {
        let mut m: BTreeMap<u8, Option<u32>> = BTreeMap::new();
        m.insert(1, None);
        m.insert(2, None);
        assert_eq!(m.count(), 2);
        assert_eq!(m.count_some(), 0);
    }

    #[test]
    fn into_option_for_vec_of_key_option_pair_empty_and_nonempty() {
        let empty: Vec<(u8, Option<u32>)> = vec![];
        assert!(
            empty.into_option().is_none(),
            "empty vec must decode to None"
        );

        let single: Vec<(u8, Option<u32>)> = vec![(1, None)];
        assert!(
            single.into_option().is_some(),
            "non-empty vec with only None values must still be Some"
        );
    }

    #[test]
    fn into_option_for_btreemap_empty_and_nonempty() {
        let empty: BTreeMap<u8, Option<u32>> = BTreeMap::new();
        assert!(empty.into_option().is_none());

        let mut m: BTreeMap<u8, Option<u32>> = BTreeMap::new();
        m.insert(1, None);
        assert!(m.into_option().is_some());
    }

    // ---------------------------------------------------------------------
    // Additional coverage: parse_key_request_type
    // ---------------------------------------------------------------------

    #[test]
    fn parse_key_request_type_specific_keys_empty_ids() {
        // Exercises the SpecificKeys branch when the id list is empty.
        use dapi_grpc::platform::v0::SpecificKeys;
        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SpecificKeys(SpecificKeys {
                key_ids: vec![],
            })),
        });
        let parsed = parse_key_request_type(&outer).unwrap();
        match parsed {
            KeyRequestType::SpecificKeys(ids) => {
                assert!(ids.is_empty(), "empty ids must round-trip as empty");
            }
            _ => panic!("expected SpecificKeys variant"),
        }
    }

    #[test]
    fn parse_key_request_type_search_key_empty_purpose_map() {
        // Exercises the SearchKey branch when the purpose map is empty.
        use dapi_grpc::platform::v0::SearchKey;
        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SearchKey(SearchKey {
                purpose_map: std::collections::HashMap::new(),
            })),
        });
        let parsed = parse_key_request_type(&outer).unwrap();
        match parsed {
            KeyRequestType::SearchKey(m) => {
                assert!(m.is_empty(), "empty map must round-trip as empty");
            }
            _ => panic!("expected SearchKey variant"),
        }
    }

    #[test]
    fn parse_key_request_type_search_key_negative_kind_rejected() {
        // Negative i32 values are not valid GrpcKeyKind values -> RequestError.
        use dapi_grpc::platform::v0::{SearchKey, SecurityLevelMap};
        let mut sec_map: std::collections::HashMap<u32, i32> = std::collections::HashMap::new();
        sec_map.insert(0, -1);
        let mut purpose_map = std::collections::HashMap::new();
        purpose_map.insert(
            0u32,
            SecurityLevelMap {
                security_level_map: sec_map,
            },
        );
        let outer = Some(GrpcKeyType {
            request: Some(key_request_type::Request::SearchKey(SearchKey {
                purpose_map,
            })),
        });
        // KeyRequestType does not implement Debug, so use `.err().expect(...)`
        // rather than `.unwrap_err()`.
        let err = parse_key_request_type(&outer)
            .err()
            .expect("negative kind must error");
        match err {
            Error::RequestError { error } => {
                assert!(error.contains("missing requested key type"), "got: {error}");
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    // ---------------------------------------------------------------------
    // Additional coverage: FromProof wrapper methods
    // ---------------------------------------------------------------------

    /// FromProof impl that always succeeds with a Some value; used for
    /// exercising the `from_proof*` wrappers' happy paths.
    #[derive(Debug, PartialEq)]
    struct PresentFromProof(u32);

    impl FromProof<()> for PresentFromProof {
        type Request = ();
        type Response = ();

        fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>(
            _request: I,
            _response: O,
            _network: Network,
            _platform_version: &PlatformVersion,
            _provider: &'a dyn ContextProvider,
        ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>
        where
            Self: Sized + 'a,
        {
            Ok((
                Some(PresentFromProof(7)),
                ResponseMetadata {
                    height: 123,
                    ..Default::default()
                },
                Proof::default(),
            ))
        }
    }

    #[test]
    fn from_proof_with_metadata_returns_value_and_metadata() {
        // Ensures the `from_proof_with_metadata` wrapper unwraps Some correctly.
        let provider = unreachable_provider();
        let (value, mtd) = <PresentFromProof as FromProof<()>>::from_proof_with_metadata(
            (),
            (),
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap();
        assert_eq!(value, PresentFromProof(7));
        assert_eq!(mtd.height, 123);
    }

    #[test]
    fn from_proof_with_metadata_and_proof_returns_all_three() {
        let provider = unreachable_provider();
        let (value, mtd, _proof) =
            <PresentFromProof as FromProof<()>>::from_proof_with_metadata_and_proof(
                (),
                (),
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap();
        assert_eq!(value, PresentFromProof(7));
        assert_eq!(mtd.height, 123);
    }

    #[test]
    fn from_proof_on_missing_returns_not_found_via_wrapper() {
        // `from_proof` forwards to `maybe_from_proof` then maps None -> NotFound.
        let provider = unreachable_provider();
        let err = <MissingFromProof as FromProof<()>>::from_proof_with_metadata(
            (),
            (),
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NotFound), "got: {err:?}");
    }

    #[test]
    fn from_proof_with_metadata_and_proof_missing_returns_not_found() {
        let provider = unreachable_provider();
        let err = <MissingFromProof as FromProof<()>>::from_proof_with_metadata_and_proof(
            (),
            (),
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NotFound), "got: {err:?}");
    }

    #[test]
    fn maybe_from_proof_delegates_to_with_metadata_and_forwards_none() {
        // `maybe_from_proof` discards metadata/proof when forwarding the
        // underlying `(None, _, _)` shape.
        let provider = unreachable_provider();
        let result = <MissingFromProof as FromProof<()>>::maybe_from_proof(
            (),
            (),
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap();
        assert!(result.is_none(), "MissingFromProof must bubble None");
    }

    // ---------------------------------------------------------------------
    // Additional coverage: more FromProof impls' decode-error paths
    // ---------------------------------------------------------------------

    fn default_metadata_with_epoch(epoch: u32) -> ResponseMetadata {
        ResponseMetadata {
            epoch,
            ..Default::default()
        }
    }

    #[test]
    fn identity_keys_rejects_bad_identity_id_length() {
        use dapi_grpc::platform::v0::get_identity_keys_request::GetIdentityKeysRequestV0;
        use platform::get_identity_keys_response::{
            get_identity_keys_response_v0::Result as V0Result, GetIdentityKeysResponseV0, Version,
        };

        let response = platform::GetIdentityKeysResponse {
            version: Some(Version::V0(GetIdentityKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityKeysRequest = GetIdentityKeysRequestV0 {
            identity_id: vec![0u8; 5], // must be 32
            request_type: None,
            limit: None,
            offset: None,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <IdentityPublicKeys as FromProof<platform::GetIdentityKeysRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_keys_rejects_overflowing_limit() {
        use dapi_grpc::platform::v0::get_identity_keys_request::GetIdentityKeysRequestV0;
        use platform::get_identity_keys_response::{
            get_identity_keys_response_v0::Result as V0Result, GetIdentityKeysResponseV0, Version,
        };

        let response = platform::GetIdentityKeysResponse {
            version: Some(Version::V0(GetIdentityKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityKeysRequest = GetIdentityKeysRequestV0 {
            identity_id: vec![0u8; 32], // valid
            request_type: None,
            limit: Some(100_000),
            offset: None,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <IdentityPublicKeys as FromProof<platform::GetIdentityKeysRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_keys_rejects_overflowing_offset() {
        use dapi_grpc::platform::v0::get_identity_keys_request::GetIdentityKeysRequestV0;
        use platform::get_identity_keys_response::{
            get_identity_keys_response_v0::Result as V0Result, GetIdentityKeysResponseV0, Version,
        };

        let response = platform::GetIdentityKeysResponse {
            version: Some(Version::V0(GetIdentityKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityKeysRequest = GetIdentityKeysRequestV0 {
            identity_id: vec![0u8; 32],
            request_type: None,
            limit: None,
            offset: Some(100_000),
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <IdentityPublicKeys as FromProof<platform::GetIdentityKeysRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_keys_rejects_missing_key_request_type() {
        // limit/offset are valid and identity_id is valid, so execution
        // reaches parse_key_request_type which errors on None.
        use dapi_grpc::platform::v0::get_identity_keys_request::GetIdentityKeysRequestV0;
        use platform::get_identity_keys_response::{
            get_identity_keys_response_v0::Result as V0Result, GetIdentityKeysResponseV0, Version,
        };

        let response = platform::GetIdentityKeysResponse {
            version: Some(Version::V0(GetIdentityKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityKeysRequest = GetIdentityKeysRequestV0 {
            identity_id: vec![0u8; 32],
            request_type: None,
            limit: None,
            offset: None,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <IdentityPublicKeys as FromProof<platform::GetIdentityKeysRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        match err {
            Error::RequestError { error } => {
                assert!(error.contains("missing key request type"), "got: {error}");
            }
            other => panic!("expected RequestError, got: {other:?}"),
        }
    }

    #[test]
    fn identity_keys_no_proof_when_response_empty() {
        let request = platform::GetIdentityKeysRequest::default();
        let response = platform::GetIdentityKeysResponse::default();
        let provider = unreachable_provider();
        let err =
            <IdentityPublicKeys as FromProof<platform::GetIdentityKeysRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn identity_nonce_rejects_bad_identity_id_length() {
        use dapi_grpc::platform::v0::get_identity_nonce_request::GetIdentityNonceRequestV0;
        use platform::get_identity_nonce_response::{
            get_identity_nonce_response_v0::Result as V0Result, GetIdentityNonceResponseV0, Version,
        };

        let response = platform::GetIdentityNonceResponse {
            version: Some(Version::V0(GetIdentityNonceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityNonceRequest = GetIdentityNonceRequestV0 {
            identity_id: vec![0u8; 1], // must be 32
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <IdentityNonceFetcher as FromProof<
            platform::GetIdentityNonceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_nonce_no_proof_when_response_empty() {
        let request = platform::GetIdentityNonceRequest::default();
        let response = platform::GetIdentityNonceResponse::default();
        let provider = unreachable_provider();
        let err = <IdentityNonceFetcher as FromProof<
            platform::GetIdentityNonceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn identity_contract_nonce_rejects_bad_identity_id_length() {
        use dapi_grpc::platform::v0::get_identity_contract_nonce_request::GetIdentityContractNonceRequestV0;
        use platform::get_identity_contract_nonce_response::{
            get_identity_contract_nonce_response_v0::Result as V0Result,
            GetIdentityContractNonceResponseV0, Version,
        };

        let response = platform::GetIdentityContractNonceResponse {
            version: Some(Version::V0(GetIdentityContractNonceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityContractNonceRequest =
            GetIdentityContractNonceRequestV0 {
                identity_id: vec![0u8; 10], // must be 32
                contract_id: vec![0u8; 32],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentityContractNonceFetcher as FromProof<
            platform::GetIdentityContractNonceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_contract_nonce_rejects_bad_contract_id_length() {
        use dapi_grpc::platform::v0::get_identity_contract_nonce_request::GetIdentityContractNonceRequestV0;
        use platform::get_identity_contract_nonce_response::{
            get_identity_contract_nonce_response_v0::Result as V0Result,
            GetIdentityContractNonceResponseV0, Version,
        };

        let response = platform::GetIdentityContractNonceResponse {
            version: Some(Version::V0(GetIdentityContractNonceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityContractNonceRequest =
            GetIdentityContractNonceRequestV0 {
                identity_id: vec![0u8; 32],
                contract_id: vec![0u8; 10], // must be 32
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentityContractNonceFetcher as FromProof<
            platform::GetIdentityContractNonceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_balance_rejects_bad_id_length() {
        use dapi_grpc::platform::v0::get_identity_balance_request::GetIdentityBalanceRequestV0;
        use platform::get_identity_balance_response::{
            get_identity_balance_response_v0::Result as V0Result, GetIdentityBalanceResponseV0,
            Version,
        };

        let response = platform::GetIdentityBalanceResponse {
            version: Some(Version::V0(GetIdentityBalanceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityBalanceRequest = GetIdentityBalanceRequestV0 {
            id: vec![0u8; 5],
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <IdentityBalance as FromProof<platform::GetIdentityBalanceRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identity_balance_empty_version_on_request_version_none() {
        // response OK; request.version None -> EmptyVersion.
        use platform::get_identity_balance_response::{
            get_identity_balance_response_v0::Result as V0Result, GetIdentityBalanceResponseV0,
            Version,
        };
        let response = platform::GetIdentityBalanceResponse {
            version: Some(Version::V0(GetIdentityBalanceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetIdentityBalanceRequest { version: None };
        let provider = unreachable_provider();
        let err =
            <IdentityBalance as FromProof<platform::GetIdentityBalanceRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn identity_balance_and_revision_rejects_bad_id_length() {
        use dapi_grpc::platform::v0::get_identity_balance_and_revision_request::GetIdentityBalanceAndRevisionRequestV0;
        use platform::get_identity_balance_and_revision_response::{
            get_identity_balance_and_revision_response_v0::Result as V0Result,
            GetIdentityBalanceAndRevisionResponseV0, Version,
        };
        let response = platform::GetIdentityBalanceAndRevisionResponse {
            version: Some(Version::V0(GetIdentityBalanceAndRevisionResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentityBalanceAndRevisionRequest =
            GetIdentityBalanceAndRevisionRequestV0 {
                id: vec![0u8; 5],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentityBalanceAndRevision as FromProof<
            platform::GetIdentityBalanceAndRevisionRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identities_balances_empty_version_none() {
        use platform::get_identities_balances_response::{
            get_identities_balances_response_v0::Result as V0Result,
            GetIdentitiesBalancesResponseV0, Version,
        };
        let response = platform::GetIdentitiesBalancesResponse {
            version: Some(Version::V0(GetIdentitiesBalancesResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetIdentitiesBalancesRequest { version: None };
        let provider = unreachable_provider();
        let err =
            <IdentityBalances as FromProof<platform::GetIdentitiesBalancesRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn data_contract_rejects_bad_id_length() {
        use dapi_grpc::platform::v0::get_data_contract_request::GetDataContractRequestV0;
        use platform::get_data_contract_response::{
            get_data_contract_response_v0::Result as V0Result, GetDataContractResponseV0, Version,
        };
        let response = platform::GetDataContractResponse {
            version: Some(Version::V0(GetDataContractResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetDataContractRequest = GetDataContractRequestV0 {
            id: vec![0u8; 5],
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <DataContract as FromProof<platform::GetDataContractRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn data_contract_no_proof_when_response_empty() {
        let request = platform::GetDataContractRequest::default();
        let response = platform::GetDataContractResponse::default();
        let provider = unreachable_provider();
        let err = <DataContract as FromProof<platform::GetDataContractRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn data_contract_with_serialization_rejects_bad_id_length() {
        // This hits the second `FromProof for (DataContract, Vec<u8>)` impl.
        use dapi_grpc::platform::v0::get_data_contract_request::GetDataContractRequestV0;
        use platform::get_data_contract_response::{
            get_data_contract_response_v0::Result as V0Result, GetDataContractResponseV0, Version,
        };
        let response = platform::GetDataContractResponse {
            version: Some(Version::V0(GetDataContractResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetDataContractRequest = GetDataContractRequestV0 {
            id: vec![0u8; 5],
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <(DataContract, Vec<u8>) as FromProof<platform::GetDataContractRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn data_contract_history_rejects_bad_id_length() {
        use dapi_grpc::platform::v0::get_data_contract_history_request::GetDataContractHistoryRequestV0;
        use platform::get_data_contract_history_response::{
            get_data_contract_history_response_v0::Result as V0Result,
            GetDataContractHistoryResponseV0, Version,
        };
        let response = platform::GetDataContractHistoryResponse {
            version: Some(Version::V0(GetDataContractHistoryResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetDataContractHistoryRequest = GetDataContractHistoryRequestV0 {
            id: vec![0u8; 5],
            limit: None,
            offset: None,
            start_at_ms: 0,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <DataContractHistory as FromProof<
            platform::GetDataContractHistoryRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn data_contract_history_rejects_overflowing_limit() {
        use dapi_grpc::platform::v0::get_data_contract_history_request::GetDataContractHistoryRequestV0;
        use platform::get_data_contract_history_response::{
            get_data_contract_history_response_v0::Result as V0Result,
            GetDataContractHistoryResponseV0, Version,
        };
        let response = platform::GetDataContractHistoryResponse {
            version: Some(Version::V0(GetDataContractHistoryResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetDataContractHistoryRequest = GetDataContractHistoryRequestV0 {
            id: vec![0u8; 32],
            limit: Some(100_000),
            offset: None,
            start_at_ms: 0,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <DataContractHistory as FromProof<
            platform::GetDataContractHistoryRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn document_history_no_proof_when_response_empty() {
        let request = platform::GetDocumentHistoryRequest::default();
        let response = platform::GetDocumentHistoryResponse::default();
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn document_history_empty_response_metadata() {
        use platform::get_document_history_response::{
            get_document_history_response_v0::Result as V0Result, GetDocumentHistoryResponseV0,
            Version,
        };
        let request = platform::GetDocumentHistoryRequest::default();
        let response = platform::GetDocumentHistoryResponse {
            version: Some(Version::V0(GetDocumentHistoryResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: None,
            })),
        };
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::EmptyResponseMetadata), "got: {err:?}");
    }

    #[test]
    fn document_history_empty_version() {
        let request = platform::GetDocumentHistoryRequest { version: None };
        let response = document_history_response_with_proof_and_metadata();
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn document_history_rejects_bad_contract_id_length() {
        let request =
            document_history_request(vec![0u8; 5], "niceDocument", vec![1u8; 32], None, None);
        let response = document_history_response_with_proof_and_metadata();
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn document_history_rejects_bad_document_id_length() {
        let request =
            document_history_request(vec![0u8; 32], "niceDocument", vec![1u8; 5], None, None);
        let response = document_history_response_with_proof_and_metadata();
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn document_history_rejects_overflowing_limit() {
        let request = document_history_request(
            vec![0u8; 32],
            "niceDocument",
            vec![1u8; 32],
            Some(100_000),
            None,
        );
        let response = document_history_response_with_proof_and_metadata();
        let provider = unreachable_provider();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn document_history_returns_not_found_when_contract_provider_misses() {
        let request =
            document_history_request(vec![0u8; 32], "niceDocument", vec![1u8; 32], None, None);
        let response = document_history_response_with_proof_and_metadata();
        let provider = NoDataContractProvider;

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::NotFound), "got: {err:?}");
    }

    #[test]
    fn document_history_rejects_unknown_document_type() {
        let data_contract = dpp::tests::fixtures::get_data_contract_fixture(
            None,
            0,
            default_platform_version().protocol_version,
        )
        .data_contract_owned();
        let contract_id = data_contract.id().to_vec();
        let provider = StaticDataContractProvider {
            data_contract: std::sync::Arc::new(data_contract),
        };
        let request =
            document_history_request(contract_id, "missingDocument", vec![1u8; 32], None, None);
        let response = document_history_response_with_proof_and_metadata();

        let err = document_history_error(request, response, &provider);

        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn address_info_rejects_bad_address_bytes() {
        // PlatformAddress::from_bytes fails for invalid lengths.
        use dapi_grpc::platform::v0::get_address_info_request::GetAddressInfoRequestV0;
        use platform::get_address_info_response::{
            get_address_info_response_v0::Result as V0Result, GetAddressInfoResponseV0, Version,
        };
        let response = platform::GetAddressInfoResponse {
            version: Some(Version::V0(GetAddressInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetAddressInfoRequest = GetAddressInfoRequestV0 {
            address: vec![0u8; 3], // not a valid address length
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <AddressInfo as FromProof<platform::GetAddressInfoRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn addresses_infos_rejects_bad_address_bytes() {
        use dapi_grpc::platform::v0::get_addresses_infos_request::GetAddressesInfosRequestV0;
        use platform::get_addresses_infos_response::{
            get_addresses_infos_response_v0::Result as V0Result, GetAddressesInfosResponseV0,
            Version,
        };
        let response = platform::GetAddressesInfosResponse {
            version: Some(Version::V0(GetAddressesInfosResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetAddressesInfosRequest = GetAddressesInfosRequestV0 {
            addresses: vec![vec![0u8; 3]],
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err =
            <AddressInfos as FromProof<platform::GetAddressesInfosRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn addresses_trunk_state_grove_no_proof() {
        // GroveTrunkQueryResult impl ignores the request entirely, so the
        // first failure possible is NoProofInResult when the response is empty.
        let response = platform::GetAddressesTrunkStateResponse::default();
        let request = platform::GetAddressesTrunkStateRequest::default();
        let provider = unreachable_provider();
        let err = <GroveTrunkQueryResult as FromProof<
            platform::GetAddressesTrunkStateRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn platform_address_trunk_state_no_proof() {
        // PlatformAddressTrunkState wraps the GroveTrunkQueryResult impl; same error.
        let response = platform::GetAddressesTrunkStateResponse::default();
        let request = platform::GetAddressesTrunkStateRequest::default();
        let provider = unreachable_provider();
        let err = <PlatformAddressTrunkState as FromProof<
            platform::GetAddressesTrunkStateRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn epochs_info_empty_version_none() {
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetEpochsInfoRequest { version: None };
        let provider = unreachable_provider();
        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn epochs_info_rejects_overflowing_count() {
        // start_epoch valid, but count > u16::MAX -> try_u32_to_u16 errors.
        use dapi_grpc::platform::v0::get_epochs_info_request::GetEpochsInfoRequestV0;
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(10)),
            })),
        };
        let request = platform::GetEpochsInfoRequest {
            version: Some(platform::get_epochs_info_request::Version::V0(
                GetEpochsInfoRequestV0 {
                    start_epoch: Some(0),
                    count: 100_000,
                    ascending: true,
                    prove: true,
                },
            )),
        };
        let provider = unreachable_provider();
        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn epochs_info_ascending_without_start_ignores_metadata_epoch() {
        // Ascending queries without a start are request-derived from epoch 0,
        // so unsigned metadata must not participate in query selection.
        use dapi_grpc::platform::v0::get_epochs_info_request::GetEpochsInfoRequestV0;
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(70_000)),
            })),
        };
        let request = platform::GetEpochsInfoRequest {
            version: Some(platform::get_epochs_info_request::Version::V0(
                GetEpochsInfoRequestV0 {
                    start_epoch: None,
                    count: 1,
                    ascending: true,
                    prove: true,
                },
            )),
        };
        let provider = unreachable_provider();
        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(
            !matches!(err, Error::RequestError { .. }),
            "metadata epoch unexpectedly influenced the request: {err:?}"
        );
    }

    #[test]
    fn epochs_info_descending_requires_explicit_start_epoch() {
        use dapi_grpc::platform::v0::get_epochs_info_request::GetEpochsInfoRequestV0;
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(10)),
            })),
        };
        let request = platform::GetEpochsInfoRequest {
            version: Some(platform::get_epochs_info_request::Version::V0(
                GetEpochsInfoRequestV0 {
                    start_epoch: None,
                    count: 1,
                    ascending: false,
                    prove: true,
                },
            )),
        };
        let provider = unreachable_provider();

        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();

        match err {
            Error::RequestError { error } => assert!(error.contains("explicit start epoch")),
            other => panic!("expected explicit-epoch request error, got: {other:?}"),
        }
    }

    #[test]
    fn epochs_info_descending_with_explicit_max_start_passes_guard() {
        // The SDK's `fetch_current` sends a descending query with an explicit
        // start (the hinted current epoch index). Any explicit start — up to
        // MAX_EPOCH, the highest index that fits Drive's epoch key encoding —
        // makes the request fully self-describing, so it must get past the
        // explicit-start guard and proceed to proof verification (which here
        // fails on the garbage proof, not on the request shape).
        use dapi_grpc::platform::v0::get_epochs_info_request::GetEpochsInfoRequestV0;
        use dpp::block::epoch::MAX_EPOCH;
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(10)),
            })),
        };
        let request = platform::GetEpochsInfoRequest {
            version: Some(platform::get_epochs_info_request::Version::V0(
                GetEpochsInfoRequestV0 {
                    start_epoch: Some(MAX_EPOCH as u32),
                    count: 1,
                    ascending: false,
                    prove: true,
                },
            )),
        };
        let provider = unreachable_provider();

        let err =
            <ExtendedEpochInfos as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();

        assert!(
            !matches!(err, Error::RequestError { .. }),
            "explicit-start descending query must pass the guard, got: {err:?}"
        );
    }

    #[test]
    fn extended_epoch_info_single_bubbles_empty_version() {
        // Ensures the wrapper passes through error from inner impl.
        use platform::get_epochs_info_response::{
            get_epochs_info_response_v0::Result as V0Result, GetEpochsInfoResponseV0, Version,
        };
        let response = platform::GetEpochsInfoResponse {
            version: Some(Version::V0(GetEpochsInfoResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetEpochsInfoRequest { version: None };
        let provider = unreachable_provider();
        let err =
            <ExtendedEpochInfo as FromProof<platform::GetEpochsInfoRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn finalized_epoch_infos_rejects_overflowing_start_index() {
        use dapi_grpc::platform::v0::get_finalized_epoch_infos_request::GetFinalizedEpochInfosRequestV0;
        use platform::get_finalized_epoch_infos_response::{
            get_finalized_epoch_infos_response_v0::Result as V0Result,
            GetFinalizedEpochInfosResponseV0, Version,
        };
        let response = platform::GetFinalizedEpochInfosResponse {
            version: Some(Version::V0(GetFinalizedEpochInfosResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetFinalizedEpochInfosRequest = GetFinalizedEpochInfosRequestV0 {
            start_epoch_index: 100_000,
            start_epoch_index_included: true,
            end_epoch_index: 1,
            end_epoch_index_included: true,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <FinalizedEpochInfos as FromProof<
            platform::GetFinalizedEpochInfosRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn finalized_epoch_infos_rejects_overflowing_end_index() {
        use dapi_grpc::platform::v0::get_finalized_epoch_infos_request::GetFinalizedEpochInfosRequestV0;
        use platform::get_finalized_epoch_infos_response::{
            get_finalized_epoch_infos_response_v0::Result as V0Result,
            GetFinalizedEpochInfosResponseV0, Version,
        };
        let response = platform::GetFinalizedEpochInfosResponse {
            version: Some(Version::V0(GetFinalizedEpochInfosResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetFinalizedEpochInfosRequest = GetFinalizedEpochInfosRequestV0 {
            start_epoch_index: 1,
            start_epoch_index_included: true,
            end_epoch_index: 100_000,
            end_epoch_index_included: true,
            prove: true,
        }
        .into();
        let provider = unreachable_provider();
        let err = <FinalizedEpochInfos as FromProof<
            platform::GetFinalizedEpochInfosRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn upgrade_state_no_proof_when_response_empty() {
        // No request dependency, so the first error must come from the response.
        let response = GetProtocolVersionUpgradeStateResponse::default();
        let request = GetProtocolVersionUpgradeStateRequest::default();
        let provider = unreachable_provider();
        let err = <ProtocolVersionUpgrades as FromProof<
            GetProtocolVersionUpgradeStateRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn upgrade_vote_status_no_proof_when_response_empty() {
        let response = GetProtocolVersionUpgradeVoteStatusResponse::default();
        let request = GetProtocolVersionUpgradeVoteStatusRequest::default();
        let provider = unreachable_provider();
        let err = <MasternodeProtocolVotes as FromProof<
            GetProtocolVersionUpgradeVoteStatusRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn upgrade_vote_status_rejects_overflowing_count() {
        use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_request::GetProtocolVersionUpgradeVoteStatusRequestV0;
        use dapi_grpc::platform::v0::get_protocol_version_upgrade_vote_status_response::{
            get_protocol_version_upgrade_vote_status_response_v0::Result as V0Result,
            GetProtocolVersionUpgradeVoteStatusResponseV0, Version,
        };

        let response = GetProtocolVersionUpgradeVoteStatusResponse {
            version: Some(Version::V0(GetProtocolVersionUpgradeVoteStatusResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        // empty start_pro_tx_hash (None branch), but count overflow
        let request: GetProtocolVersionUpgradeVoteStatusRequest =
            GetProtocolVersionUpgradeVoteStatusRequestV0 {
                start_pro_tx_hash: vec![],
                count: 100_000,
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <MasternodeProtocolVotes as FromProof<
            GetProtocolVersionUpgradeVoteStatusRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn path_elements_empty_version_when_no_version() {
        // Response has full v0 shell, request has None -> EmptyVersion.
        use platform::get_path_elements_response::{
            get_path_elements_response_v0::Result as V0Result, GetPathElementsResponseV0, Version,
        };
        let response = GetPathElementsResponse {
            version: Some(Version::V0(GetPathElementsResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = GetPathElementsRequest { version: None };
        let provider = unreachable_provider();
        let err = <Elements as FromProof<GetPathElementsRequest>>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn identities_contract_keys_rejects_bad_identity_id() {
        use dapi_grpc::platform::v0::get_identities_contract_keys_request::GetIdentitiesContractKeysRequestV0;
        use platform::get_identities_contract_keys_response::{
            get_identities_contract_keys_response_v0::Result as V0Result,
            GetIdentitiesContractKeysResponseV0, Version,
        };
        let response = platform::GetIdentitiesContractKeysResponse {
            version: Some(Version::V0(GetIdentitiesContractKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentitiesContractKeysRequest =
            GetIdentitiesContractKeysRequestV0 {
                identities_ids: vec![vec![0u8; 5]], // bad
                contract_id: vec![0u8; 32],
                document_type_name: None,
                purposes: vec![0],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentitiesContractKeys as FromProof<
            platform::GetIdentitiesContractKeysRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identities_contract_keys_rejects_bad_contract_id() {
        use dapi_grpc::platform::v0::get_identities_contract_keys_request::GetIdentitiesContractKeysRequestV0;
        use platform::get_identities_contract_keys_response::{
            get_identities_contract_keys_response_v0::Result as V0Result,
            GetIdentitiesContractKeysResponseV0, Version,
        };
        let response = platform::GetIdentitiesContractKeysResponse {
            version: Some(Version::V0(GetIdentitiesContractKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request: platform::GetIdentitiesContractKeysRequest =
            GetIdentitiesContractKeysRequestV0 {
                identities_ids: vec![vec![0u8; 32]],
                contract_id: vec![0u8; 5], // bad
                document_type_name: None,
                purposes: vec![0],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentitiesContractKeys as FromProof<
            platform::GetIdentitiesContractKeysRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn identities_contract_keys_rejects_bad_purpose() {
        use dapi_grpc::platform::v0::get_identities_contract_keys_request::GetIdentitiesContractKeysRequestV0;
        use platform::get_identities_contract_keys_response::{
            get_identities_contract_keys_response_v0::Result as V0Result,
            GetIdentitiesContractKeysResponseV0, Version,
        };
        let response = platform::GetIdentitiesContractKeysResponse {
            version: Some(Version::V0(GetIdentitiesContractKeysResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        // purpose 250 is not a valid Purpose value.
        let request: platform::GetIdentitiesContractKeysRequest =
            GetIdentitiesContractKeysRequestV0 {
                identities_ids: vec![vec![0u8; 32]],
                contract_id: vec![0u8; 32],
                document_type_name: None,
                purposes: vec![250],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <IdentitiesContractKeys as FromProof<
            platform::GetIdentitiesContractKeysRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    #[test]
    fn prefunded_balance_empty_version_on_request_version_none() {
        // response has proof; request.version = None -> EmptyVersion
        use platform::get_prefunded_specialized_balance_response::{
            get_prefunded_specialized_balance_response_v0::Result as V0Result,
            GetPrefundedSpecializedBalanceResponseV0, Version,
        };
        let response = platform::GetPrefundedSpecializedBalanceResponse {
            version: Some(Version::V0(GetPrefundedSpecializedBalanceResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetPrefundedSpecializedBalanceRequest { version: None };
        let provider = unreachable_provider();
        let err = <PrefundedSpecializedBalance as FromProof<
            platform::GetPrefundedSpecializedBalanceRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_ids_empty_version() {
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetEvonodesProposedEpochBlocksByIdsRequest { version: None };
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByIdsRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_ids_rejects_overflowing_epoch() {
        // Request sets epoch > u16::MAX -> try_u32_to_u16 error.
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_ids_request::GetEvonodesProposedEpochBlocksByIdsRequestV0;
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(1)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByIdsRequest =
            GetEvonodesProposedEpochBlocksByIdsRequestV0 {
                epoch: Some(100_000),
                ids: vec![],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByIdsRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_ids_requires_explicit_epoch() {
        // An omitted epoch must fail before unsigned metadata can select the
        // proof query.
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_ids_request::GetEvonodesProposedEpochBlocksByIdsRequestV0;
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(99_999)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByIdsRequest =
            GetEvonodesProposedEpochBlocksByIdsRequestV0 {
                epoch: None,
                ids: vec![],
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByIdsRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_range_empty_version() {
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetEvonodesProposedEpochBlocksByRangeRequest { version: None };
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByRangeRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_range_requires_explicit_epoch() {
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_range_request::GetEvonodesProposedEpochBlocksByRangeRequestV0;
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(99_999)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByRangeRequest =
            GetEvonodesProposedEpochBlocksByRangeRequestV0 {
                epoch: None,
                limit: None,
                start: None,
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByRangeRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();

        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_range_rejects_bad_start_after() {
        // Start::StartAfter with wrong length must fail.
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_range_request::{
            get_evonodes_proposed_epoch_blocks_by_range_request_v0::Start,
            GetEvonodesProposedEpochBlocksByRangeRequestV0,
        };
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(1)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByRangeRequest =
            GetEvonodesProposedEpochBlocksByRangeRequestV0 {
                epoch: Some(1),
                limit: None,
                start: Some(Start::StartAfter(vec![0u8; 5])),
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByRangeRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::DriveError { .. }), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_range_rejects_bad_start_at() {
        // Start::StartAt with wrong length must fail.
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_range_request::{
            get_evonodes_proposed_epoch_blocks_by_range_request_v0::Start,
            GetEvonodesProposedEpochBlocksByRangeRequestV0,
        };
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(1)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByRangeRequest =
            GetEvonodesProposedEpochBlocksByRangeRequestV0 {
                epoch: Some(1),
                limit: None,
                start: Some(Start::StartAt(vec![0u8; 4])),
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByRangeRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::DriveError { .. }), "got: {err:?}");
    }

    #[test]
    fn evonodes_proposed_epoch_blocks_by_range_rejects_overflow_limit() {
        use dapi_grpc::platform::v0::get_evonodes_proposed_epoch_blocks_by_range_request::GetEvonodesProposedEpochBlocksByRangeRequestV0;
        use platform::get_evonodes_proposed_epoch_blocks_response::{
            get_evonodes_proposed_epoch_blocks_response_v0::Result as V0Result,
            GetEvonodesProposedEpochBlocksResponseV0, Version,
        };
        let response = platform::GetEvonodesProposedEpochBlocksResponse {
            version: Some(Version::V0(GetEvonodesProposedEpochBlocksResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(default_metadata_with_epoch(1)),
            })),
        };
        let request: platform::GetEvonodesProposedEpochBlocksByRangeRequest =
            GetEvonodesProposedEpochBlocksByRangeRequestV0 {
                epoch: Some(1),
                limit: Some(100_000),
                start: None,
                prove: true,
            }
            .into();
        let provider = unreachable_provider();
        let err = <ProposerBlockCounts as FromProof<
            platform::GetEvonodesProposedEpochBlocksByRangeRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn shielded_pool_state_no_proof_when_response_empty() {
        let response = platform::GetShieldedPoolStateResponse::default();
        let request = platform::GetShieldedPoolStateRequest::default();
        let provider = unreachable_provider();
        let err = <ShieldedPoolState as FromProof<
            platform::GetShieldedPoolStateRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn shielded_notes_count_no_proof_when_response_empty() {
        let response = platform::GetShieldedNotesCountResponse::default();
        let request = platform::GetShieldedNotesCountRequest::default();
        let provider = unreachable_provider();
        let err = <ShieldedNotesCount as FromProof<
            platform::GetShieldedNotesCountRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn shielded_anchors_no_proof_when_response_empty() {
        let response = platform::GetShieldedAnchorsResponse::default();
        let request = platform::GetShieldedAnchorsRequest::default();
        let provider = unreachable_provider();
        let err =
            <ShieldedAnchors as FromProof<platform::GetShieldedAnchorsRequest>>::maybe_from_proof(
                request,
                response,
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn most_recent_shielded_anchor_no_proof_when_response_empty() {
        let response = platform::GetMostRecentShieldedAnchorResponse::default();
        let request = platform::GetMostRecentShieldedAnchorRequest::default();
        let provider = unreachable_provider();
        let err = <MostRecentShieldedAnchor as FromProof<
            platform::GetMostRecentShieldedAnchorRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn shielded_encrypted_notes_empty_version_on_request_version_none() {
        use platform::get_shielded_encrypted_notes_response::{
            get_shielded_encrypted_notes_response_v0::Result as V0Result,
            GetShieldedEncryptedNotesResponseV0, Version,
        };
        let response = platform::GetShieldedEncryptedNotesResponse {
            version: Some(Version::V0(GetShieldedEncryptedNotesResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetShieldedEncryptedNotesRequest { version: None };
        let provider = unreachable_provider();
        let err = <ShieldedEncryptedNotes as FromProof<
            platform::GetShieldedEncryptedNotesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn shielded_encrypted_notes_no_proof_when_response_empty() {
        let response = platform::GetShieldedEncryptedNotesResponse::default();
        let request = platform::GetShieldedEncryptedNotesRequest::default();
        let provider = unreachable_provider();
        let err = <ShieldedEncryptedNotes as FromProof<
            platform::GetShieldedEncryptedNotesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn shielded_nullifiers_empty_version_on_request_version_none() {
        use platform::get_shielded_nullifiers_response::{
            get_shielded_nullifiers_response_v0::Result as V0Result,
            GetShieldedNullifiersResponseV0, Version,
        };
        let response = platform::GetShieldedNullifiersResponse {
            version: Some(Version::V0(GetShieldedNullifiersResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetShieldedNullifiersRequest { version: None };
        let provider = unreachable_provider();
        let err = <ShieldedNullifierStatuses as FromProof<
            platform::GetShieldedNullifiersRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn recent_address_balance_changes_empty_version() {
        use platform::get_recent_address_balance_changes_response::{
            get_recent_address_balance_changes_response_v0::Result as V0Result,
            GetRecentAddressBalanceChangesResponseV0, Version,
        };
        let response = platform::GetRecentAddressBalanceChangesResponse {
            version: Some(Version::V0(GetRecentAddressBalanceChangesResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: Some(ResponseMetadata::default()),
            })),
        };
        let request = platform::GetRecentAddressBalanceChangesRequest { version: None };
        let provider = unreachable_provider();
        let err = <RecentAddressBalanceChanges as FromProof<
            platform::GetRecentAddressBalanceChangesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn recent_compacted_address_balance_changes_empty_version() {
        use platform::get_recent_compacted_address_balance_changes_response::{
            get_recent_compacted_address_balance_changes_response_v0::Result as V0Result,
            GetRecentCompactedAddressBalanceChangesResponseV0, Version,
        };
        let response = platform::GetRecentCompactedAddressBalanceChangesResponse {
            version: Some(Version::V0(
                GetRecentCompactedAddressBalanceChangesResponseV0 {
                    result: Some(V0Result::Proof(Proof::default())),
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };
        let request = platform::GetRecentCompactedAddressBalanceChangesRequest { version: None };
        let provider = unreachable_provider();
        let err = <RecentCompactedAddressBalanceChanges as FromProof<
            platform::GetRecentCompactedAddressBalanceChangesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn vote_identity_vote_rejects_bad_identity_id_length() {
        // The request is validated before the proof is read.
        use dapi_grpc::platform::v0::get_contested_resource_identity_votes_request::get_contested_resource_identity_votes_request_v0::StartAtVotePollIdInfo;
        use dapi_grpc::platform::v0::get_contested_resource_identity_votes_request::GetContestedResourceIdentityVotesRequestV0;
        let request: platform::GetContestedResourceIdentityVotesRequest =
            GetContestedResourceIdentityVotesRequestV0 {
                identity_id: vec![0u8; 5], // bad
                limit: Some(1),
                offset: None,
                order_ascending: true,
                start_at_vote_poll_id_info: Some(StartAtVotePollIdInfo {
                    start_at_poll_identifier: vec![1u8; 32],
                    start_poll_identifier_included: true,
                }),
                prove: true,
            }
            .into();
        let response = platform::GetContestedResourceIdentityVotesResponse::default();
        let provider = unreachable_provider();
        let err = <Vote as FromProof<
            platform::GetContestedResourceIdentityVotesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
    }

    #[test]
    fn should_refuse_a_vote_request_that_does_not_start_at_its_vote_poll() {
        // The proved votes are keyed by vote poll id, so without the poll the request starts
        // at, including it, there is no vote to pick from them. Such a request is refused
        // before it is sent: refused only once a node answered, it would count against that
        // node although the node answered it correctly.
        use dapi_grpc::platform::v0::get_contested_resource_identity_votes_request::get_contested_resource_identity_votes_request_v0::StartAtVotePollIdInfo;
        use dapi_grpc::platform::v0::get_contested_resource_identity_votes_request::GetContestedResourceIdentityVotesRequestV0;
        let request =
            |start_at_vote_poll_id_info| -> platform::GetContestedResourceIdentityVotesRequest {
                GetContestedResourceIdentityVotesRequestV0 {
                    identity_id: vec![7u8; 32],
                    limit: Some(1),
                    offset: None,
                    order_ascending: true,
                    start_at_vote_poll_id_info,
                    prove: true,
                }
                .into()
            };

        let starting_at_its_vote_poll = request(Some(StartAtVotePollIdInfo {
            start_at_poll_identifier: vec![1u8; 32],
            start_poll_identifier_included: true,
        }));
        <Vote as FromProof<platform::GetContestedResourceIdentityVotesRequest>>::check_request(
            &starting_at_its_vote_poll,
            default_platform_version(),
        )
        .expect("a request starting at its vote poll is sent");

        for start_at_vote_poll_id_info in [
            None,
            Some(StartAtVotePollIdInfo {
                start_at_poll_identifier: vec![1u8; 32],
                start_poll_identifier_included: false,
            }),
            // Not a vote poll id: 5 bytes instead of 32.
            Some(StartAtVotePollIdInfo {
                start_at_poll_identifier: vec![1u8; 5],
                start_poll_identifier_included: true,
            }),
        ] {
            let request = request(start_at_vote_poll_id_info);
            let err = <Vote as FromProof<
                platform::GetContestedResourceIdentityVotesRequest,
            >>::check_request(&request, default_platform_version())
            .unwrap_err();
            assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");

            let provider = unreachable_provider();
            let err = <Vote as FromProof<
                platform::GetContestedResourceIdentityVotesRequest,
            >>::maybe_from_proof(
                request,
                platform::GetContestedResourceIdentityVotesResponse::default(),
                Network::Testnet,
                default_platform_version(),
                &provider,
            )
            .unwrap_err();
            assert!(matches!(err, Error::RequestError { .. }), "got: {err:?}");
        }
    }

    #[test]
    fn vote_identity_vote_empty_version_on_request_none() {
        let request = platform::GetContestedResourceIdentityVotesRequest { version: None };
        let response = platform::GetContestedResourceIdentityVotesResponse::default();
        let provider = unreachable_provider();
        let err = <Vote as FromProof<
            platform::GetContestedResourceIdentityVotesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    #[test]
    fn resource_votes_by_identity_empty_version_via_try_from_request() {
        // Delegates to ContestedResourceVotesGivenByIdentityQuery::try_from_request,
        // which returns Error::EmptyVersion when the request version is missing.
        let request = platform::GetContestedResourceIdentityVotesRequest { version: None };
        let response = platform::GetContestedResourceIdentityVotesResponse::default();
        let provider = unreachable_provider();
        let err = <ResourceVotesByIdentity as FromProof<
            platform::GetContestedResourceIdentityVotesRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::EmptyVersion), "got: {err:?}");
    }

    // ---------------------------------------------------------------------
    // IntoOption for more types
    // ---------------------------------------------------------------------

    #[test]
    fn into_option_indexmap_empty_vs_with_entry_only_none() {
        use dpp::prelude::Identifier;
        let empty: RetrievedObjects<Identifier, u32> = RetrievedObjects::new();
        assert!(empty.into_option().is_none());

        let mut map: RetrievedObjects<Identifier, u32> = RetrievedObjects::new();
        map.insert(Identifier::new([7u8; 32]), None);
        let mapped = map.into_option();
        assert!(
            mapped.is_some(),
            "absence markers must be preserved in into_option"
        );
        assert_eq!(mapped.unwrap().len(), 1);
    }

    // ---------------------------------------------------------------------
    // Additional: extend existing malformed request tests to all StateTransitions
    // ---------------------------------------------------------------------

    #[test]
    fn broadcast_state_transition_no_proof_when_response_empty() {
        let request = platform::BroadcastStateTransitionRequest {
            state_transition: vec![],
        };
        let response = platform::WaitForStateTransitionResultResponse::default();
        let provider = unreachable_provider();
        let err = <StateTransitionProofOutcome as FromProof<
            platform::BroadcastStateTransitionRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::NoProofInResult), "got: {err:?}");
    }

    #[test]
    fn broadcast_state_transition_protocol_error_fires_before_metadata_check() {
        // This test pins the ORDERING of validation in
        // `StateTransitionProofOutcome::maybe_from_proof` for broadcast
        // state transitions: proof extraction -> state_transition decode ->
        // metadata check. An invalid state_transition payload triggers
        // `ProtocolError` on decode BEFORE the missing-metadata branch is
        // reached, so even though `metadata: None` here, the assertion
        // targets `ProtocolError`, not `EmptyResponseMetadata`.
        //
        // (For the happy-path `EmptyResponseMetadata` branch, a valid
        // serialized state transition would be needed; that is covered
        // elsewhere. This test deliberately documents the decode-first
        // ordering.)
        use platform::wait_for_state_transition_result_response::{
            wait_for_state_transition_result_response_v0::Result as V0Result, Version,
            WaitForStateTransitionResultResponseV0,
        };
        let request = platform::BroadcastStateTransitionRequest {
            state_transition: vec![0xFFu8; 4],
        };
        let response = platform::WaitForStateTransitionResultResponse {
            version: Some(Version::V0(WaitForStateTransitionResultResponseV0 {
                result: Some(V0Result::Proof(Proof::default())),
                metadata: None, // missing — would trigger EmptyResponseMetadata if reached
            })),
        };
        let provider = unreachable_provider();
        let err = <StateTransitionProofOutcome as FromProof<
            platform::BroadcastStateTransitionRequest,
        >>::maybe_from_proof(
            request,
            response,
            Network::Testnet,
            default_platform_version(),
            &provider,
        )
        .unwrap_err();
        assert!(matches!(err, Error::ProtocolError { .. }), "got: {err:?}");
    }

    /// Every direct-proof `FromProof` path rejects a legacy envelope before
    /// its bytes reach Drive, whatever else the request carries. The provider
    /// panics if touched, so a case that reaches it has lost the gate.
    mod legacy_envelope_gate {
        use super::*;
        use crate::types::groups::{GroupActionSigners, GroupActions, Groups};
        use crate::types::identity_token_balance::{
            IdentitiesTokenBalances, IdentityTokenBalances,
        };
        use crate::types::token_info::{IdentitiesTokenInfos, IdentityTokenInfos};
        use crate::types::token_status::TokenStatuses;
        use dpp::balances::total_single_token_balance::TotalSingleTokenBalance;
        use dpp::data_contract::group::Group;
        use dpp::tokens::contract_info::TokenContractInfo;

        fn legacy_proof() -> Proof {
            Proof {
                grovedb_proof: bincode::encode_to_vec(
                    0u32,
                    bincode::config::standard().with_big_endian(),
                )
                .expect("V0 envelope discriminant should encode"),
                ..Proof::default()
            }
        }

        fn id(byte: u8) -> Vec<u8> {
            vec![byte; 32]
        }

        macro_rules! request {
            ($module:ident, $v0:ident, $request:ident { $($field:ident: $value:expr),* $(,)? }) => {
                {
                    // Some request bodies list every field; keep one macro
                    // shape for all of them.
                    #[allow(clippy::needless_update)]
                    let body = platform::$module::$v0 {
                        $($field: $value,)*
                        ..Default::default()
                    };
                    platform::$request {
                        version: Some(platform::$module::Version::V0(body)),
                    }
                }
            };
        }

        macro_rules! legacy_response {
            ($module:ident, $v0_module:ident, $v0:ident, $response:ident) => {
                platform::$response {
                    version: Some(platform::$module::Version::V0(platform::$module::$v0 {
                        result: Some(platform::$module::$v0_module::Result::Proof(legacy_proof())),
                        metadata: Some(ResponseMetadata::default()),
                    })),
                }
            };
        }

        macro_rules! assert_rejects_legacy_envelope {
            ($target:ty, $request_type:ty, $request:expr, $response:expr) => {{
                let error = <$target as FromProof<$request_type>>::maybe_from_proof(
                    $request,
                    $response,
                    Network::Testnet,
                    PlatformVersion::latest(),
                    &unreachable_provider(),
                )
                .expect_err(concat!(
                    stringify!($target),
                    " must reject a legacy envelope"
                ));
                assert!(
                    matches!(
                        error,
                        Error::UnsupportedGroveDBProofVersion {
                            version: 0,
                            minimum: 1,
                            ..
                        }
                    ),
                    "{}: {error:?}",
                    stringify!($target)
                );
            }};
        }

        #[test]
        fn identity_queries() {
            assert_rejects_legacy_envelope!(
                Identity,
                platform::GetIdentityRequest,
                request!(
                    get_identity_request,
                    GetIdentityRequestV0,
                    GetIdentityRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_response,
                    get_identity_response_v0,
                    GetIdentityResponseV0,
                    GetIdentityResponse
                )
            );
            assert_rejects_legacy_envelope!(
                Identity,
                platform::GetIdentityByPublicKeyHashRequest,
                request!(
                    get_identity_by_public_key_hash_request,
                    GetIdentityByPublicKeyHashRequestV0,
                    GetIdentityByPublicKeyHashRequest {
                        public_key_hash: vec![1; 20],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_by_public_key_hash_response,
                    get_identity_by_public_key_hash_response_v0,
                    GetIdentityByPublicKeyHashResponseV0,
                    GetIdentityByPublicKeyHashResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityPublicKeys,
                platform::GetIdentityKeysRequest,
                request!(
                    get_identity_keys_request,
                    GetIdentityKeysRequestV0,
                    GetIdentityKeysRequest {
                        identity_id: id(1),
                        request_type: Some(platform::KeyRequestType {
                            request: Some(platform::key_request_type::Request::AllKeys(
                                platform::AllKeys {}
                            )),
                        }),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_keys_response,
                    get_identity_keys_response_v0,
                    GetIdentityKeysResponseV0,
                    GetIdentityKeysResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityNonceFetcher,
                platform::GetIdentityNonceRequest,
                request!(
                    get_identity_nonce_request,
                    GetIdentityNonceRequestV0,
                    GetIdentityNonceRequest {
                        identity_id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_nonce_response,
                    get_identity_nonce_response_v0,
                    GetIdentityNonceResponseV0,
                    GetIdentityNonceResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityContractNonceFetcher,
                platform::GetIdentityContractNonceRequest,
                request!(
                    get_identity_contract_nonce_request,
                    GetIdentityContractNonceRequestV0,
                    GetIdentityContractNonceRequest {
                        identity_id: id(1),
                        contract_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_contract_nonce_response,
                    get_identity_contract_nonce_response_v0,
                    GetIdentityContractNonceResponseV0,
                    GetIdentityContractNonceResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityBalance,
                platform::GetIdentityBalanceRequest,
                request!(
                    get_identity_balance_request,
                    GetIdentityBalanceRequestV0,
                    GetIdentityBalanceRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_balance_response,
                    get_identity_balance_response_v0,
                    GetIdentityBalanceResponseV0,
                    GetIdentityBalanceResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityBalances,
                platform::GetIdentitiesBalancesRequest,
                request!(
                    get_identities_balances_request,
                    GetIdentitiesBalancesRequestV0,
                    GetIdentitiesBalancesRequest {
                        ids: vec![id(1)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identities_balances_response,
                    get_identities_balances_response_v0,
                    GetIdentitiesBalancesResponseV0,
                    GetIdentitiesBalancesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityBalanceAndRevision,
                platform::GetIdentityBalanceAndRevisionRequest,
                request!(
                    get_identity_balance_and_revision_request,
                    GetIdentityBalanceAndRevisionRequestV0,
                    GetIdentityBalanceAndRevisionRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_balance_and_revision_response,
                    get_identity_balance_and_revision_response_v0,
                    GetIdentityBalanceAndRevisionResponseV0,
                    GetIdentityBalanceAndRevisionResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentitiesContractKeys,
                platform::GetIdentitiesContractKeysRequest,
                request!(
                    get_identities_contract_keys_request,
                    GetIdentitiesContractKeysRequestV0,
                    GetIdentitiesContractKeysRequest {
                        identities_ids: vec![id(1)],
                        contract_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identities_contract_keys_response,
                    get_identities_contract_keys_response_v0,
                    GetIdentitiesContractKeysResponseV0,
                    GetIdentitiesContractKeysResponse
                )
            );
        }

        #[test]
        fn contract_and_address_queries() {
            assert_rejects_legacy_envelope!(
                DataContract,
                platform::GetDataContractRequest,
                request!(
                    get_data_contract_request,
                    GetDataContractRequestV0,
                    GetDataContractRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_data_contract_response,
                    get_data_contract_response_v0,
                    GetDataContractResponseV0,
                    GetDataContractResponse
                )
            );
            assert_rejects_legacy_envelope!(
                (DataContract, Vec<u8>),
                platform::GetDataContractRequest,
                request!(
                    get_data_contract_request,
                    GetDataContractRequestV0,
                    GetDataContractRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_data_contract_response,
                    get_data_contract_response_v0,
                    GetDataContractResponseV0,
                    GetDataContractResponse
                )
            );
            assert_rejects_legacy_envelope!(
                DataContracts,
                platform::GetDataContractsRequest,
                request!(
                    get_data_contracts_request,
                    GetDataContractsRequestV0,
                    GetDataContractsRequest {
                        ids: vec![id(1)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_data_contracts_response,
                    get_data_contracts_response_v0,
                    GetDataContractsResponseV0,
                    GetDataContractsResponse
                )
            );
            assert_rejects_legacy_envelope!(
                DataContractHistory,
                platform::GetDataContractHistoryRequest,
                request!(
                    get_data_contract_history_request,
                    GetDataContractHistoryRequestV0,
                    GetDataContractHistoryRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_data_contract_history_response,
                    get_data_contract_history_response_v0,
                    GetDataContractHistoryResponseV0,
                    GetDataContractHistoryResponse
                )
            );
            assert_rejects_legacy_envelope!(
                AddressInfos,
                platform::GetAddressesInfosRequest,
                request!(
                    get_addresses_infos_request,
                    GetAddressesInfosRequestV0,
                    GetAddressesInfosRequest { prove: true }
                ),
                legacy_response!(
                    get_addresses_infos_response,
                    get_addresses_infos_response_v0,
                    GetAddressesInfosResponseV0,
                    GetAddressesInfosResponse
                )
            );
            assert_rejects_legacy_envelope!(
                RecentAddressBalanceChanges,
                platform::GetRecentAddressBalanceChangesRequest,
                request!(
                    get_recent_address_balance_changes_request,
                    GetRecentAddressBalanceChangesRequestV0,
                    GetRecentAddressBalanceChangesRequest {
                        start_height: 1,
                        prove: true
                    }
                ),
                legacy_response!(
                    get_recent_address_balance_changes_response,
                    get_recent_address_balance_changes_response_v0,
                    GetRecentAddressBalanceChangesResponseV0,
                    GetRecentAddressBalanceChangesResponse
                )
            );
            // The trunk response carries its proof directly rather than in a
            // `result` oneof, so it cannot use `legacy_response!`. Without the
            // gate a V0 envelope reaches GroveDB's V0 trunk verifier, whose
            // `count == 0` fast path skips the value-hash chain and lets a
            // prover present the address tree as empty.
            use platform::get_addresses_trunk_state_response::{
                GetAddressesTrunkStateResponseV0, Version as TrunkStateVersion,
            };
            let legacy_trunk_state_response = || platform::GetAddressesTrunkStateResponse {
                version: Some(TrunkStateVersion::V0(GetAddressesTrunkStateResponseV0 {
                    proof: Some(legacy_proof()),
                    metadata: Some(ResponseMetadata::default()),
                })),
            };
            assert_rejects_legacy_envelope!(
                GroveTrunkQueryResult,
                platform::GetAddressesTrunkStateRequest,
                request!(
                    get_addresses_trunk_state_request,
                    GetAddressesTrunkStateRequestV0,
                    GetAddressesTrunkStateRequest {}
                ),
                legacy_trunk_state_response()
            );
            assert_rejects_legacy_envelope!(
                PlatformAddressTrunkState,
                platform::GetAddressesTrunkStateRequest,
                request!(
                    get_addresses_trunk_state_request,
                    GetAddressesTrunkStateRequestV0,
                    GetAddressesTrunkStateRequest {}
                ),
                legacy_trunk_state_response()
            );
            assert_rejects_legacy_envelope!(
                PrefundedSpecializedBalance,
                platform::GetPrefundedSpecializedBalanceRequest,
                request!(
                    get_prefunded_specialized_balance_request,
                    GetPrefundedSpecializedBalanceRequestV0,
                    GetPrefundedSpecializedBalanceRequest {
                        id: id(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_prefunded_specialized_balance_response,
                    get_prefunded_specialized_balance_response_v0,
                    GetPrefundedSpecializedBalanceResponseV0,
                    GetPrefundedSpecializedBalanceResponse
                )
            );
            assert_rejects_legacy_envelope!(
                VotePollsGroupedByTimestamp,
                platform::GetVotePollsByEndDateRequest,
                request!(
                    get_vote_polls_by_end_date_request,
                    GetVotePollsByEndDateRequestV0,
                    GetVotePollsByEndDateRequest { prove: true }
                ),
                legacy_response!(
                    get_vote_polls_by_end_date_response,
                    get_vote_polls_by_end_date_response_v0,
                    GetVotePollsByEndDateResponseV0,
                    GetVotePollsByEndDateResponse
                )
            );
        }

        #[test]
        fn system_queries() {
            assert_rejects_legacy_envelope!(
                ExtendedEpochInfos,
                platform::GetEpochsInfoRequest,
                request!(
                    get_epochs_info_request,
                    GetEpochsInfoRequestV0,
                    GetEpochsInfoRequest {
                        count: 1,
                        ascending: true,
                        prove: true
                    }
                ),
                legacy_response!(
                    get_epochs_info_response,
                    get_epochs_info_response_v0,
                    GetEpochsInfoResponseV0,
                    GetEpochsInfoResponse
                )
            );
            assert_rejects_legacy_envelope!(
                FinalizedEpochInfos,
                platform::GetFinalizedEpochInfosRequest,
                request!(
                    get_finalized_epoch_infos_request,
                    GetFinalizedEpochInfosRequestV0,
                    GetFinalizedEpochInfosRequest {
                        end_epoch_index: 1,
                        prove: true
                    }
                ),
                legacy_response!(
                    get_finalized_epoch_infos_response,
                    get_finalized_epoch_infos_response_v0,
                    GetFinalizedEpochInfosResponseV0,
                    GetFinalizedEpochInfosResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ProtocolVersionUpgrades,
                platform::GetProtocolVersionUpgradeStateRequest,
                request!(
                    get_protocol_version_upgrade_state_request,
                    GetProtocolVersionUpgradeStateRequestV0,
                    GetProtocolVersionUpgradeStateRequest { prove: true }
                ),
                legacy_response!(
                    get_protocol_version_upgrade_state_response,
                    get_protocol_version_upgrade_state_response_v0,
                    GetProtocolVersionUpgradeStateResponseV0,
                    GetProtocolVersionUpgradeStateResponse
                )
            );
            assert_rejects_legacy_envelope!(
                MasternodeProtocolVotes,
                platform::GetProtocolVersionUpgradeVoteStatusRequest,
                request!(
                    get_protocol_version_upgrade_vote_status_request,
                    GetProtocolVersionUpgradeVoteStatusRequestV0,
                    GetProtocolVersionUpgradeVoteStatusRequest {
                        count: 1,
                        prove: true
                    }
                ),
                legacy_response!(
                    get_protocol_version_upgrade_vote_status_response,
                    get_protocol_version_upgrade_vote_status_response_v0,
                    GetProtocolVersionUpgradeVoteStatusResponseV0,
                    GetProtocolVersionUpgradeVoteStatusResponse
                )
            );
            assert_rejects_legacy_envelope!(
                Elements,
                platform::GetPathElementsRequest,
                request!(
                    get_path_elements_request,
                    GetPathElementsRequestV0,
                    GetPathElementsRequest { prove: true }
                ),
                legacy_response!(
                    get_path_elements_response,
                    get_path_elements_response_v0,
                    GetPathElementsResponseV0,
                    GetPathElementsResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TotalCreditsInPlatform,
                platform::GetTotalCreditsInPlatformRequest,
                request!(
                    get_total_credits_in_platform_request,
                    GetTotalCreditsInPlatformRequestV0,
                    GetTotalCreditsInPlatformRequest { prove: true }
                ),
                legacy_response!(
                    get_total_credits_in_platform_response,
                    get_total_credits_in_platform_response_v0,
                    GetTotalCreditsInPlatformResponseV0,
                    GetTotalCreditsInPlatformResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ProposerBlockCounts,
                platform::GetEvonodesProposedEpochBlocksByIdsRequest,
                request!(
                    get_evonodes_proposed_epoch_blocks_by_ids_request,
                    GetEvonodesProposedEpochBlocksByIdsRequestV0,
                    GetEvonodesProposedEpochBlocksByIdsRequest {
                        epoch: Some(1),
                        ids: vec![id(1)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_evonodes_proposed_epoch_blocks_response,
                    get_evonodes_proposed_epoch_blocks_response_v0,
                    GetEvonodesProposedEpochBlocksResponseV0,
                    GetEvonodesProposedEpochBlocksResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ProposerBlockCounts,
                platform::GetEvonodesProposedEpochBlocksByRangeRequest,
                request!(
                    get_evonodes_proposed_epoch_blocks_by_range_request,
                    GetEvonodesProposedEpochBlocksByRangeRequestV0,
                    GetEvonodesProposedEpochBlocksByRangeRequest {
                        epoch: Some(1),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_evonodes_proposed_epoch_blocks_response,
                    get_evonodes_proposed_epoch_blocks_response_v0,
                    GetEvonodesProposedEpochBlocksResponseV0,
                    GetEvonodesProposedEpochBlocksResponse
                )
            );
        }

        #[test]
        fn shielded_queries() {
            assert_rejects_legacy_envelope!(
                ShieldedPoolState,
                platform::GetShieldedPoolStateRequest,
                request!(
                    get_shielded_pool_state_request,
                    GetShieldedPoolStateRequestV0,
                    GetShieldedPoolStateRequest {
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_shielded_pool_state_response,
                    get_shielded_pool_state_response_v0,
                    GetShieldedPoolStateResponseV0,
                    GetShieldedPoolStateResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ShieldedNotesCount,
                platform::GetShieldedNotesCountRequest,
                request!(
                    get_shielded_notes_count_request,
                    GetShieldedNotesCountRequestV0,
                    GetShieldedNotesCountRequest {
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_shielded_notes_count_response,
                    get_shielded_notes_count_response_v0,
                    GetShieldedNotesCountResponseV0,
                    GetShieldedNotesCountResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ShieldedAnchors,
                platform::GetShieldedAnchorsRequest,
                request!(
                    get_shielded_anchors_request,
                    GetShieldedAnchorsRequestV0,
                    GetShieldedAnchorsRequest {
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_shielded_anchors_response,
                    get_shielded_anchors_response_v0,
                    GetShieldedAnchorsResponseV0,
                    GetShieldedAnchorsResponse
                )
            );
            assert_rejects_legacy_envelope!(
                MostRecentShieldedAnchor,
                platform::GetMostRecentShieldedAnchorRequest,
                request!(
                    get_most_recent_shielded_anchor_request,
                    GetMostRecentShieldedAnchorRequestV0,
                    GetMostRecentShieldedAnchorRequest {
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_most_recent_shielded_anchor_response,
                    get_most_recent_shielded_anchor_response_v0,
                    GetMostRecentShieldedAnchorResponseV0,
                    GetMostRecentShieldedAnchorResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ShieldedEncryptedNotes,
                platform::GetShieldedEncryptedNotesRequest,
                request!(
                    get_shielded_encrypted_notes_request,
                    GetShieldedEncryptedNotesRequestV0,
                    GetShieldedEncryptedNotesRequest {
                        count: 1,
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_shielded_encrypted_notes_response,
                    get_shielded_encrypted_notes_response_v0,
                    GetShieldedEncryptedNotesResponseV0,
                    GetShieldedEncryptedNotesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                ShieldedNullifierStatuses,
                platform::GetShieldedNullifiersRequest,
                request!(
                    get_shielded_nullifiers_request,
                    GetShieldedNullifiersRequestV0,
                    GetShieldedNullifiersRequest {
                        nullifiers: vec![id(1)],
                        prove: true,
                        token_id: None
                    }
                ),
                legacy_response!(
                    get_shielded_nullifiers_response,
                    get_shielded_nullifiers_response_v0,
                    GetShieldedNullifiersResponseV0,
                    GetShieldedNullifiersResponse
                )
            );
        }

        #[test]
        fn token_and_group_queries() {
            assert_rejects_legacy_envelope!(
                IdentityTokenBalances,
                platform::GetIdentityTokenBalancesRequest,
                request!(
                    get_identity_token_balances_request,
                    GetIdentityTokenBalancesRequestV0,
                    GetIdentityTokenBalancesRequest {
                        identity_id: id(1),
                        token_ids: vec![id(2)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_token_balances_response,
                    get_identity_token_balances_response_v0,
                    GetIdentityTokenBalancesResponseV0,
                    GetIdentityTokenBalancesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentitiesTokenBalances,
                platform::GetIdentitiesTokenBalancesRequest,
                request!(
                    get_identities_token_balances_request,
                    GetIdentitiesTokenBalancesRequestV0,
                    GetIdentitiesTokenBalancesRequest {
                        token_id: id(2),
                        identity_ids: vec![id(1)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identities_token_balances_response,
                    get_identities_token_balances_response_v0,
                    GetIdentitiesTokenBalancesResponseV0,
                    GetIdentitiesTokenBalancesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentityTokenInfos,
                platform::GetIdentityTokenInfosRequest,
                request!(
                    get_identity_token_infos_request,
                    GetIdentityTokenInfosRequestV0,
                    GetIdentityTokenInfosRequest {
                        identity_id: id(1),
                        token_ids: vec![id(2)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identity_token_infos_response,
                    get_identity_token_infos_response_v0,
                    GetIdentityTokenInfosResponseV0,
                    GetIdentityTokenInfosResponse
                )
            );
            assert_rejects_legacy_envelope!(
                IdentitiesTokenInfos,
                platform::GetIdentitiesTokenInfosRequest,
                request!(
                    get_identities_token_infos_request,
                    GetIdentitiesTokenInfosRequestV0,
                    GetIdentitiesTokenInfosRequest {
                        token_id: id(2),
                        identity_ids: vec![id(1)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_identities_token_infos_response,
                    get_identities_token_infos_response_v0,
                    GetIdentitiesTokenInfosResponseV0,
                    GetIdentitiesTokenInfosResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TokenStatuses,
                platform::GetTokenStatusesRequest,
                request!(
                    get_token_statuses_request,
                    GetTokenStatusesRequestV0,
                    GetTokenStatusesRequest {
                        token_ids: vec![id(2)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_token_statuses_response,
                    get_token_statuses_response_v0,
                    GetTokenStatusesResponseV0,
                    GetTokenStatusesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TotalSingleTokenBalance,
                platform::GetTokenTotalSupplyRequest,
                request!(
                    get_token_total_supply_request,
                    GetTokenTotalSupplyRequestV0,
                    GetTokenTotalSupplyRequest {
                        token_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_token_total_supply_response,
                    get_token_total_supply_response_v0,
                    GetTokenTotalSupplyResponseV0,
                    GetTokenTotalSupplyResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TokenContractInfo,
                platform::GetTokenContractInfoRequest,
                request!(
                    get_token_contract_info_request,
                    GetTokenContractInfoRequestV0,
                    GetTokenContractInfoRequest {
                        token_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_token_contract_info_response,
                    get_token_contract_info_response_v0,
                    GetTokenContractInfoResponseV0,
                    GetTokenContractInfoResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TokenDirectPurchasePrices,
                platform::GetTokenDirectPurchasePricesRequest,
                request!(
                    get_token_direct_purchase_prices_request,
                    GetTokenDirectPurchasePricesRequestV0,
                    GetTokenDirectPurchasePricesRequest {
                        token_ids: vec![id(2)],
                        prove: true
                    }
                ),
                legacy_response!(
                    get_token_direct_purchase_prices_response,
                    get_token_direct_purchase_prices_response_v0,
                    GetTokenDirectPurchasePricesResponseV0,
                    GetTokenDirectPurchasePricesResponse
                )
            );
            assert_rejects_legacy_envelope!(
                TokenPreProgrammedDistributions,
                platform::GetTokenPreProgrammedDistributionsRequest,
                request!(
                    get_token_pre_programmed_distributions_request,
                    GetTokenPreProgrammedDistributionsRequestV0,
                    GetTokenPreProgrammedDistributionsRequest {
                        token_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_token_pre_programmed_distributions_response,
                    get_token_pre_programmed_distributions_response_v0,
                    GetTokenPreProgrammedDistributionsResponseV0,
                    GetTokenPreProgrammedDistributionsResponse
                )
            );
            assert_rejects_legacy_envelope!(
                Group,
                platform::GetGroupInfoRequest,
                request!(
                    get_group_info_request,
                    GetGroupInfoRequestV0,
                    GetGroupInfoRequest {
                        contract_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_group_info_response,
                    get_group_info_response_v0,
                    GetGroupInfoResponseV0,
                    GetGroupInfoResponse
                )
            );
            assert_rejects_legacy_envelope!(
                Groups,
                platform::GetGroupInfosRequest,
                request!(
                    get_group_infos_request,
                    GetGroupInfosRequestV0,
                    GetGroupInfosRequest {
                        contract_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_group_infos_response,
                    get_group_infos_response_v0,
                    GetGroupInfosResponseV0,
                    GetGroupInfosResponse
                )
            );
            assert_rejects_legacy_envelope!(
                GroupActions,
                platform::GetGroupActionsRequest,
                request!(
                    get_group_actions_request,
                    GetGroupActionsRequestV0,
                    GetGroupActionsRequest {
                        contract_id: id(2),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_group_actions_response,
                    get_group_actions_response_v0,
                    GetGroupActionsResponseV0,
                    GetGroupActionsResponse
                )
            );
            assert_rejects_legacy_envelope!(
                GroupActionSigners,
                platform::GetGroupActionSignersRequest,
                request!(
                    get_group_action_signers_request,
                    GetGroupActionSignersRequestV0,
                    GetGroupActionSignersRequest {
                        contract_id: id(2),
                        action_id: id(3),
                        prove: true
                    }
                ),
                legacy_response!(
                    get_group_action_signers_response,
                    get_group_action_signers_response_v0,
                    GetGroupActionSignersResponseV0,
                    GetGroupActionSignersResponse
                )
            );
        }
    }
}