drive_proof_verifier/

unproved.rs

use crate::types::contract_groups::{
    contract_group_info_from_proto, members_page_from_response, members_query_from_request,
    memberships_from_response, ContractGroupInfo, ContractGroupMembersPage,
    ContractGroupMembershipsForContract,
};
use crate::types::contract_moderation::{
    entries_from_response, fee_pots_from_response, list_from_request, lists_from_request,
    moderation_action_counts_from_response, reason_from_response, removals_from_response,
    removals_query_from_request, team_action_signers_from_response,
    team_action_status_from_request, team_actions_from_response, team_actions_query_from_request,
    warnings_from_response, ContractBan, ContractDocumentRemovals, ContractFeePots,
    ContractModerationActionCounts, ContractModerationEntries, ContractModerationList,
    ContractModerationListStatuses, ContractModerationStatus, ContractSuspension,
    ContractTeamActionSigners, ContractTeamActions,
};
use crate::types::data_contracts_latest_versions::{
    DataContractLatestVersion, DataContractsLatestVersions,
};
use crate::types::evonode_status::EvoNodeStatus;
use crate::types::identity_keys_remaining_budgets::IdentityKeysRemainingBudgets;
use crate::types::CurrentQuorumsInfo;
use crate::Error;
use dapi_grpc::platform::v0::ResponseMetadata;
use dapi_grpc::platform::v0::{self as platform};
use dapi_grpc::platform::v0::get_contract_moderation_action_counts_response::get_contract_moderation_action_counts_response_v0::Result as ModerationActionCountsResult;
use dapi_grpc::tonic::async_trait;
use dpp::bls_signatures::PublicKey as BlsPublicKey;
use dpp::core_types::validator::v0::ValidatorV0;
use dpp::core_types::validator_set::v0::ValidatorSetV0;
use dpp::core_types::validator_set::ValidatorSet;
use dpp::dashcore::hashes::Hash;
use dpp::dashcore::{Network, ProTxHash, PubkeyHash, QuorumHash};
use dpp::data_contract::DataContract;
use dpp::identifier::Identifier;
use dpp::serialization::PlatformDeserializableWithPotentialValidationFromVersionedStructureUntrusted;
use dpp::version::PlatformVersion;
use std::collections::BTreeMap;

fn parse_hash_32(field: &str, bytes: &[u8]) -> Result<[u8; 32], Error> {
    bytes.try_into().map_err(|_| Error::ProtocolError {
        error: format!(
            "Invalid {field} length: expected 32 bytes, received {}",
            bytes.len()
        ),
    })
}

/// Trait for parsing unproved responses from the Platform.
///
/// This trait defines methods for extracting data from responses received from the Platform
/// without the need for cryptographic proof validation. It is primarily used for scenarios where
/// the proof data is not available or not required, and only the data itself is needed.
///
/// ## Associated Types
///
/// - `Request`: The type of the request sent to the server. This represents the format of the
///   data that the platform expects when making a query.
/// - `Response`: The type of the response received from the server. This represents the format of
///   the data returned by the platform after executing the query.
///
/// ## Methods
///
/// - `maybe_from_unproved`: Parses the response to retrieve the requested object, if any.
/// - `maybe_from_unproved_with_metadata`: Parses the response to retrieve the requested object
///   along with response metadata, if any.
/// - `from_unproved`: Retrieves the requested object from the response, returning an error if the
///   object is not found.
/// - `from_unproved_with_metadata`: Retrieves the requested object from the response along with
///   metadata, returning an error if the object is not found.
///
/// ```
pub trait FromUnproved<Req> {
    /// Request type for which this trait is implemented.
    type Request;
    /// Response type for which this trait is implemented.
    type Response;

    /// Parse the received response 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/Regtest).
    /// * `platform_version`: The platform version that should be used.
    ///
    /// # Returns
    ///
    /// * `Ok(Some(object))` when the requested object was found in the response.
    /// * `Ok(None)` when the requested object was not found.
    /// * `Err(Error)` when parsing fails or data is invalid.
    fn maybe_from_unproved<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<Option<Self>, Error>
    where
        Self: Sized,
    {
        Self::maybe_from_unproved_with_metadata(request, response, network, platform_version)
            .map(|maybe_result| maybe_result.0)
    }

    /// Parse the received response and retrieve the requested object along with metadata, 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/Regtest).
    /// * `platform_version`: The platform version that should be used.
    ///
    /// # Returns
    ///
    /// * `Ok((Some(object), metadata))` when the requested object was found.
    /// * `Ok((None, metadata))` when the requested object was not found.
    /// * `Err(Error)` when parsing fails or data is invalid.
    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized;

    /// Retrieve the requested object from the response.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using.
    /// * `platform_version`: The platform version that should be used.
    ///
    /// # Returns
    ///
    /// * `Ok(object)` when the requested object was found.
    /// * `Err(Error::NotFound)` when the requested object was not found.
    /// * `Err(Error)` when parsing fails or data is invalid.
    fn from_unproved<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<Self, Error>
    where
        Self: Sized,
    {
        Self::maybe_from_unproved(request, response, network, platform_version)?
            .ok_or(Error::NotFound)
    }

    /// Retrieve the requested object from the response along with metadata.
    ///
    /// # Arguments
    ///
    /// * `request`: The request sent to the server.
    /// * `response`: The response received from the server.
    /// * `network`: The network we are using.
    /// * `platform_version`: The platform version that should be used.
    ///
    /// # Returns
    ///
    /// * `Ok((object, metadata))` when the requested object was found.
    /// * `Err(Error::NotFound)` when the requested object was not found.
    /// * `Err(Error)` when parsing fails or data is invalid.
    fn from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<(Self, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        let (main_item, response_metadata) =
            Self::maybe_from_unproved_with_metadata(request, response, network, platform_version)?;
        Ok((main_item.ok_or(Error::NotFound)?, response_metadata))
    }
}

impl FromUnproved<platform::GetCurrentQuorumsInfoRequest> for CurrentQuorumsInfo {
    type Request = platform::GetCurrentQuorumsInfoRequest;
    type Response = platform::GetCurrentQuorumsInfoResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        // Convert the response into a GetCurrentQuorumsInfoResponse
        let response: platform::GetCurrentQuorumsInfoResponse = response.into();

        // Extract metadata from the response
        let metadata = match &response.version {
            Some(platform::get_current_quorums_info_response::Version::V0(ref v0)) => {
                v0.metadata.clone()
            }
            None => None,
        }
        .ok_or(Error::EmptyResponseMetadata)?;

        // Parse response based on the version field
        let info = match response.version.ok_or(Error::EmptyVersion)? {
            platform::get_current_quorums_info_response::Version::V0(v0) => {
                // Extract quorum hashes
                let quorum_hashes = v0
                    .quorum_hashes
                    .into_iter()
                    .map(|q_hash| parse_hash_32("quorum_hash", &q_hash))
                    .collect::<Result<Vec<[u8; 32]>, Error>>()?;

                // Extract current quorum hash
                let current_quorum_hash =
                    parse_hash_32("current_quorum_hash", &v0.current_quorum_hash)?;

                let last_block_proposer =
                    parse_hash_32("last_block_proposer", &v0.last_block_proposer)?;

                // Extract validator sets
                let validator_sets =
                    v0.validator_sets
                        .into_iter()
                        .map(|vs| {
                            // Parse the ValidatorSetV0
                            let quorum_hash =
                                parse_hash_32("validator_set.quorum_hash", &vs.quorum_hash)?;

                            // Parse ValidatorV0 members
                            let members = vs
                                .members
                                .into_iter()
                                .map(|member| {
                                    let pro_tx_hash = ProTxHash::from_slice(&member.pro_tx_hash)
                                        .map_err(|_| Error::ProtocolError {
                                            error: "Invalid ProTxHash format".to_string(),
                                        })?;
                                    let validator = ValidatorV0 {
                                        pro_tx_hash,
                                        public_key: None, // Assuming it's not provided here
                                        node_ip: member.node_ip,
                                        node_id: PubkeyHash::from_slice(&[0; 20]).expect("expected to make pub key hash from 20 byte empty array"), // Placeholder, since not provided
                                        core_port: 0, // Placeholder, since not provided
                                        platform_http_port: 0, // Placeholder, since not provided
                                        platform_p2p_port: 0, // Placeholder, since not provided
                                        is_banned: member.is_banned,
                                    };
                                    Ok((pro_tx_hash, validator))
                                })
                                .collect::<Result<BTreeMap<ProTxHash, ValidatorV0>, Error>>()?;

                            Ok(ValidatorSet::V0(ValidatorSetV0 {
                                quorum_hash: QuorumHash::from_slice(quorum_hash.as_slice())
                                    .map_err(|_| Error::ProtocolError {
                                        error: "Invalid Quorum Hash format".to_string(),
                                    })?,
                                quorum_index: None, // Assuming it's not provided here
                                core_height: vs.core_height,
                                members,
                                threshold_public_key: BlsPublicKey::try_from(
                                    vs.threshold_public_key.as_slice(),
                                )
                                .map_err(|_| Error::ProtocolError {
                                    error: "Invalid BlsPublicKey format".to_string(),
                                })?,
                            }))
                        })
                        .collect::<Result<Vec<ValidatorSet>, Error>>()?;

                // Create the CurrentQuorumsInfo struct
                Ok::<CurrentQuorumsInfo, Error>(CurrentQuorumsInfo {
                    quorum_hashes,
                    current_quorum_hash,
                    validator_sets,
                    last_block_proposer,
                    last_platform_block_height: metadata.height,
                    last_core_block_height: metadata.core_chain_locked_height,
                })
            }
        }?;

        Ok((Some(info), metadata))
    }
}

#[async_trait]
impl FromUnproved<platform::GetStatusRequest> for EvoNodeStatus {
    type Request = platform::GetStatusRequest;
    type Response = platform::GetStatusResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        let status = Self::try_from(response.into())?;
        // we use default response metadata, as this request does not return any metadata
        Ok((Some(status), Default::default()))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use dapi_grpc::platform::v0::{
        get_current_quorums_info_response, get_status_response, ResponseMetadata,
    };
    use dpp::bls_signatures::{Bls12381G2Impl, SecretKey};
    use dpp::version::PlatformVersion;

    /// Generate a valid BLS public key as compressed bytes (48 bytes) from a
    /// deterministic secret key derived from the given seed byte.
    fn generate_valid_bls_public_key_bytes(seed: u8) -> Vec<u8> {
        let mut secret_bytes = [0u8; 32];
        secret_bytes[31] = seed.max(1); // ensure nonzero
        let sk: SecretKey<Bls12381G2Impl> =
            SecretKey::<Bls12381G2Impl>::from_be_bytes(&secret_bytes)
                .into_option()
                .expect("valid secret key");
        sk.public_key().0.to_compressed().to_vec()
    }

    /// Helper: build a valid GetCurrentQuorumsInfoResponse with one quorum hash,
    /// one validator set with one member, and metadata.
    fn build_valid_quorums_info_response() -> platform::GetCurrentQuorumsInfoResponse {
        let quorum_hash = vec![1u8; 32];
        let current_quorum_hash = vec![2u8; 32];
        let last_block_proposer = vec![3u8; 32];
        let pro_tx_hash = vec![4u8; 32];
        let threshold_public_key = generate_valid_bls_public_key_bytes(42);

        let member = get_current_quorums_info_response::ValidatorV0 {
            pro_tx_hash: pro_tx_hash.clone(),
            node_ip: "127.0.0.1".to_string(),
            is_banned: false,
        };

        let validator_set = get_current_quorums_info_response::ValidatorSetV0 {
            quorum_hash: quorum_hash.clone(),
            core_height: 100,
            members: vec![member],
            threshold_public_key,
        };

        let v0 = get_current_quorums_info_response::GetCurrentQuorumsInfoResponseV0 {
            quorum_hashes: vec![quorum_hash],
            current_quorum_hash,
            validator_sets: vec![validator_set],
            last_block_proposer,
            metadata: Some(ResponseMetadata {
                height: 500,
                core_chain_locked_height: 200,
                epoch: 10,
                time_ms: 1234567890,
                protocol_version: 1,
                chain_id: "dash-testnet-1".to_string(),
            }),
        };

        platform::GetCurrentQuorumsInfoResponse {
            version: Some(get_current_quorums_info_response::Version::V0(v0)),
        }
    }

    /// Helper: build a valid GetStatusResponse V0 with all inner fields populated.
    fn build_valid_status_response() -> platform::GetStatusResponse {
        use dapi_grpc::platform::v0::get_status_response::get_status_response_v0;

        let software = get_status_response_v0::version::Software {
            dapi: "1.0.0".to_string(),
            drive: Some("2.0.0".to_string()),
            tenderdash: Some("0.14.0".to_string()),
        };

        let tenderdash_protocol =
            get_status_response_v0::version::protocol::Tenderdash { p2p: 8, block: 11 };

        let drive_protocol = get_status_response_v0::version::protocol::Drive {
            latest: 5,
            current: 4,
            next_epoch: 5,
        };

        let protocol = get_status_response_v0::version::Protocol {
            tenderdash: Some(tenderdash_protocol),
            drive: Some(drive_protocol),
        };

        let version = get_status_response_v0::Version {
            software: Some(software),
            protocol: Some(protocol),
        };

        let time = get_status_response_v0::Time {
            local: 1700000000,
            block: Some(1699999900),
            genesis: Some(1690000000),
            epoch: Some(42),
        };

        let node = get_status_response_v0::Node {
            id: vec![10u8; 20],
            pro_tx_hash: Some(vec![11u8; 32]),
        };

        let chain = get_status_response_v0::Chain {
            catching_up: false,
            latest_block_hash: vec![20u8; 32],
            latest_app_hash: vec![21u8; 32],
            latest_block_height: 1000,
            earliest_block_hash: vec![22u8; 32],
            earliest_app_hash: vec![23u8; 32],
            earliest_block_height: 1,
            max_peer_block_height: 1001,
            core_chain_locked_height: Some(500),
        };

        let network = get_status_response_v0::Network {
            chain_id: "dash-testnet-1".to_string(),
            peers_count: 25,
            listening: true,
        };

        let state_sync = get_status_response_v0::StateSync {
            total_synced_time: 3600,
            remaining_time: 120,
            total_snapshots: 5,
            chunk_process_avg_time: 50,
            snapshot_height: 900,
            snapshot_chunks_count: 100,
            backfilled_blocks: 800,
            backfill_blocks_total: 1000,
        };

        let v0 = get_status_response::GetStatusResponseV0 {
            version: Some(version),
            node: Some(node),
            chain: Some(chain),
            network: Some(network),
            state_sync: Some(state_sync),
            time: Some(time),
        };

        platform::GetStatusResponse {
            version: Some(get_status_response::Version::V0(v0)),
        }
    }

    #[test]
    fn test_current_quorums_info_valid_response() {
        let request = platform::GetCurrentQuorumsInfoRequest { version: None };
        let response = build_valid_quorums_info_response();
        let platform_version = PlatformVersion::latest();

        let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let (maybe_info, metadata) = result.expect("should parse valid response");
        let info = maybe_info.expect("should contain CurrentQuorumsInfo");

        assert_eq!(info.quorum_hashes.len(), 1);
        assert_eq!(info.quorum_hashes[0], [1u8; 32]);
        assert_eq!(info.current_quorum_hash, [2u8; 32]);
        assert_eq!(info.last_block_proposer, [3u8; 32]);
        assert_eq!(info.validator_sets.len(), 1);
        assert_eq!(info.last_platform_block_height, 500);
        assert_eq!(info.last_core_block_height, 200);
        assert_eq!(metadata.height, 500);
        assert_eq!(metadata.core_chain_locked_height, 200);
    }

    #[test]
    fn test_current_quorums_info_invalid_quorum_hash_length() {
        let mut response = build_valid_quorums_info_response();

        // Inject an invalid quorum_hash that is not 32 bytes
        if let Some(get_current_quorums_info_response::Version::V0(ref mut v0)) = response.version {
            v0.quorum_hashes = vec![vec![0u8; 16]]; // 16 bytes instead of 32
        }

        let request = platform::GetCurrentQuorumsInfoRequest { version: None };
        let platform_version = PlatformVersion::latest();

        let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let err = result.expect_err("should fail for invalid quorum_hash length");
        let err_string = err.to_string();
        assert!(
            err_string.contains("Invalid quorum_hash length"),
            "unexpected error: {err_string}"
        );
    }

    #[test]
    fn test_current_quorums_info_invalid_current_quorum_hash_length() {
        let mut response = build_valid_quorums_info_response();

        // Inject an invalid current_quorum_hash that is not 32 bytes
        if let Some(get_current_quorums_info_response::Version::V0(ref mut v0)) = response.version {
            v0.current_quorum_hash = vec![0u8; 10]; // 10 bytes instead of 32
        }

        let request = platform::GetCurrentQuorumsInfoRequest { version: None };
        let platform_version = PlatformVersion::latest();

        let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let err = result.expect_err("should fail for invalid current_quorum_hash length");
        let err_string = err.to_string();
        assert!(
            err_string.contains("Invalid current_quorum_hash length"),
            "unexpected error: {err_string}"
        );
    }

    #[test]
    fn test_current_quorums_info_invalid_last_block_proposer() {
        let mut response = build_valid_quorums_info_response();

        // Inject an invalid last_block_proposer that is not 32 bytes
        if let Some(get_current_quorums_info_response::Version::V0(ref mut v0)) = response.version {
            v0.last_block_proposer = vec![0u8; 5]; // 5 bytes instead of 32
        }

        let request = platform::GetCurrentQuorumsInfoRequest { version: None };
        let platform_version = PlatformVersion::latest();

        let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let err = result.expect_err("should fail for invalid last_block_proposer length");
        let err_string = err.to_string();
        assert!(
            err_string.contains("Invalid last_block_proposer length"),
            "unexpected error: {err_string}"
        );
    }

    #[test]
    fn test_current_quorums_info_rejects_malformed_nested_quorum_hashes() {
        for invalid_length in [0, 1, 31, 33, 1024] {
            let mut response = build_valid_quorums_info_response();
            if let Some(get_current_quorums_info_response::Version::V0(ref mut v0)) =
                response.version
            {
                v0.validator_sets[0].quorum_hash = vec![0u8; invalid_length];
            }

            let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
                platform::GetCurrentQuorumsInfoRequest { version: None },
                response,
                Network::Testnet,
                PlatformVersion::latest(),
            );

            let error = result.expect_err("malformed nested quorum hash must return an error");
            assert!(
                matches!(error, Error::ProtocolError { ref error } if error.contains("validator_set.quorum_hash")),
                "unexpected error for length {invalid_length}: {error:?}"
            );
        }
    }

    #[test]
    fn test_current_quorums_info_none_metadata() {
        let mut response = build_valid_quorums_info_response();

        // Remove metadata from the response
        if let Some(get_current_quorums_info_response::Version::V0(ref mut v0)) = response.version {
            v0.metadata = None;
        }

        let request = platform::GetCurrentQuorumsInfoRequest { version: None };
        let platform_version = PlatformVersion::latest();

        let result = CurrentQuorumsInfo::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let err = result.expect_err("should fail when metadata is missing");
        let err_string = err.to_string();
        assert!(
            err_string.contains("empty response metadata"),
            "unexpected error: {err_string}"
        );
    }

    #[test]
    fn test_evo_node_status_valid_response() {
        let request = platform::GetStatusRequest { version: None };
        let response = build_valid_status_response();
        let platform_version = PlatformVersion::latest();

        let result = EvoNodeStatus::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            platform_version,
        );

        let (maybe_status, _metadata) = result.expect("should parse valid status response");
        let status = maybe_status.expect("should contain EvoNodeStatus");

        // Verify version fields
        let software = status.version.software.as_ref().unwrap();
        assert_eq!(software.dapi, "1.0.0");
        assert_eq!(software.drive.as_deref(), Some("2.0.0"));
        assert_eq!(software.tenderdash.as_deref(), Some("0.14.0"));

        let protocol = status.version.protocol.as_ref().unwrap();
        let td = protocol.tenderdash.as_ref().unwrap();
        assert_eq!(td.p2p, 8);
        assert_eq!(td.block, 11);
        let drv = protocol.drive.as_ref().unwrap();
        assert_eq!(drv.latest, 5);
        assert_eq!(drv.current, 4);
        assert_eq!(drv.next_epoch, 5);

        // Verify node fields
        assert_eq!(status.node.id, vec![10u8; 20]);
        assert_eq!(status.node.pro_tx_hash, Some(vec![11u8; 32]));

        // Verify chain fields
        assert!(!status.chain.catching_up);
        assert_eq!(status.chain.latest_block_height, 1000);
        assert_eq!(status.chain.core_chain_locked_height, Some(500));

        // Verify network fields
        assert_eq!(status.network.chain_id, "dash-testnet-1");
        assert_eq!(status.network.peers_count, 25);
        assert!(status.network.listening);

        // Verify time fields
        assert_eq!(status.time.local, 1700000000);
        assert_eq!(status.time.block, Some(1699999900));
        assert_eq!(status.time.epoch, Some(42));
    }
}

impl FromUnproved<platform::GetDataContractsLatestVersionsRequest> for DataContractsLatestVersions {
    type Request = platform::GetDataContractsLatestVersionsRequest;
    type Response = platform::GetDataContractsLatestVersionsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_data_contracts_latest_versions_response::get_data_contracts_latest_versions_response_v0::Result as V0Result;

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

        let platform::get_data_contracts_latest_versions_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let versions = match v0.result {
            Some(V0Result::DataContractsLatestVersions(versions)) => versions
                .entries
                .into_iter()
                .map(|entry| {
                    let id = Identifier::from_bytes(&entry.identifier).map_err(|e| {
                        Error::ProtocolError {
                            error: e.to_string(),
                        }
                    })?;
                    let latest_version = entry
                        .version
                        .map(|version| {
                            let data_contract = entry
                                .data_contract
                                .map(|bytes| {
                                    DataContract::versioned_deserialize_untrusted(
                                        &bytes,
                                        false,
                                        platform_version,
                                    )
                                })
                                .transpose()
                                .map_err(|e| Error::ProtocolError {
                                    error: e.to_string(),
                                })?;
                            Ok::<_, Error>(DataContractLatestVersion {
                                version,
                                data_contract,
                            })
                        })
                        .transpose()?;
                    Ok((id, latest_version))
                })
                .collect::<Result<DataContractsLatestVersions, Error>>()
                .map(Some)?,
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved data contract versions, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((versions, metadata))
    }
}

#[cfg(test)]
mod data_contracts_latest_versions_tests {
    use super::*;
    use dapi_grpc::platform::v0::get_data_contracts_latest_versions_response::{
        get_data_contracts_latest_versions_response_v0::Result as V0Result,
        DataContractLatestVersionEntry, DataContractsLatestVersions as ProtoLatestVersions,
        GetDataContractsLatestVersionsResponseV0, Version,
    };
    use dpp::data_contract::accessors::v0::DataContractV0Getters;
    use dpp::serialization::PlatformSerializableWithPlatformVersion;
    use dpp::tests::fixtures::get_data_contract_fixture;

    fn response(result: Option<V0Result>) -> platform::GetDataContractsLatestVersionsResponse {
        platform::GetDataContractsLatestVersionsResponse {
            version: Some(Version::V0(GetDataContractsLatestVersionsResponseV0 {
                result,
                metadata: Some(ResponseMetadata::default()),
            })),
        }
    }

    fn parse(
        response: platform::GetDataContractsLatestVersionsResponse,
    ) -> Result<Option<DataContractsLatestVersions>, Error> {
        <DataContractsLatestVersions as FromUnproved<
            platform::GetDataContractsLatestVersionsRequest,
        >>::maybe_from_unproved(
            platform::GetDataContractsLatestVersionsRequest::default(),
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
    }

    #[test]
    fn version_only_entries_carry_no_contract_and_missing_ids_map_to_none() {
        let versions = parse(response(Some(V0Result::DataContractsLatestVersions(
            ProtoLatestVersions {
                entries: vec![
                    DataContractLatestVersionEntry {
                        identifier: vec![1; 32],
                        version: Some(7),
                        data_contract: None,
                    },
                    DataContractLatestVersionEntry {
                        identifier: vec![2; 32],
                        version: None,
                        data_contract: None,
                    },
                ],
            },
        ))))
        .expect("parse")
        .expect("present");

        assert_eq!(versions.0.len(), 2);
        assert_eq!(versions.version_of(&Identifier::new([1; 32])), Some(7));
        assert!(versions.0[&Identifier::new([1; 32])]
            .as_ref()
            .expect("found")
            .data_contract
            .is_none());
        assert_eq!(versions.0[&Identifier::new([2; 32])], None);
        assert_eq!(versions.version_of(&Identifier::new([3; 32])), None);
    }

    #[test]
    fn included_contract_is_deserialized() {
        let platform_version = PlatformVersion::latest();
        let contract = get_data_contract_fixture(None, 0, platform_version.protocol_version)
            .data_contract_owned();
        let bytes = contract
            .serialize_to_bytes_with_platform_version(platform_version)
            .expect("serialize");

        let versions = parse(response(Some(V0Result::DataContractsLatestVersions(
            ProtoLatestVersions {
                entries: vec![DataContractLatestVersionEntry {
                    identifier: contract.id().to_vec(),
                    version: Some(contract.version()),
                    data_contract: Some(bytes),
                }],
            },
        ))))
        .expect("parse")
        .expect("present");

        let entry = versions.0[&contract.id()].clone().expect("found");
        assert_eq!(entry.version, contract.version());
        assert_eq!(entry.data_contract, Some(contract));
    }

    #[test]
    fn a_proof_where_values_were_expected_is_rejected() {
        let err = parse(response(Some(V0Result::Proof(platform::Proof::default())))).unwrap_err();
        assert!(
            matches!(err, Error::ResponseDecodeError { .. }),
            "got: {err:?}"
        );
    }

    #[test]
    fn missing_metadata_is_rejected() {
        let response = platform::GetDataContractsLatestVersionsResponse {
            version: Some(Version::V0(GetDataContractsLatestVersionsResponseV0 {
                result: None,
                metadata: None,
            })),
        };
        let err = parse(response).unwrap_err();
        assert!(matches!(err, Error::EmptyResponseMetadata), "got: {err:?}");
    }
}

impl FromUnproved<platform::GetContractGroupInfoRequest> for ContractGroupInfo {
    type Request = platform::GetContractGroupInfoRequest;
    type Response = platform::GetContractGroupInfoResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_group_info_response::get_contract_group_info_response_v0::Result as V0Result;

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

        let platform::get_contract_group_info_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let info = match v0.result {
            Some(V0Result::ContractGroupInfo(info)) => Some(contract_group_info_from_proto(info)?),
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract group info, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((info, metadata))
    }
}

impl FromUnproved<platform::GetContractModerationStatusRequest> for ContractModerationListStatuses {
    type Request = platform::GetContractModerationStatusRequest;
    type Response = platform::GetContractModerationStatusResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_moderation_status_response::get_contract_moderation_status_response_v0::Result as V0Result;

        // The response holds a flat status. Only the lists the request named are reported, and
        // only when the response says it read them.
        let request: Self::Request = request.into();
        let platform::get_contract_moderation_status_request::Version::V0(request_v0) =
            request.version.ok_or(Error::EmptyVersion)?;
        let lists = lists_from_request(&request_v0.lists)?;

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

        let platform::get_contract_moderation_status_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let status = match v0.result {
            Some(V0Result::Status(status)) => {
                // The response says which lists it read. A list asked for and not among them
                // was not read, so nothing may be reported about it, least of all "not banned".
                let covered: Vec<ContractModerationList> = status
                    .lists
                    .iter()
                    .filter_map(|list| list_from_request(*list, "lists").ok())
                    .collect();
                if let Some(missing) = lists.iter().find(|list| !covered.contains(list)) {
                    return Err(Error::ResponseDecodeError {
                        error: format!(
                            "contract moderation status does not cover the {missing} asked for"
                        ),
                    });
                }
                let banned = match status.banned {
                    Some(banned) => banned,
                    None if lists.contains(&ContractModerationList::Banlist) => {
                        return Err(Error::ResponseDecodeError {
                            error: "contract moderation status covers the banlist but does not \
                                    say whether the identity is banned"
                                .to_string(),
                        })
                    }
                    None => false,
                };
                // An entry comes with its reason. Only the lists asked for are decoded, since
                // only they are reported.
                let ban = (banned && lists.contains(&ContractModerationList::Banlist))
                    .then(|| reason_from_response(status.ban_reason))
                    .transpose()?
                    .map(|reason| ContractBan { reason });
                let suspension = status
                    .suspended_until
                    .filter(|_| lists.contains(&ContractModerationList::Suspensions))
                    .map(|until| {
                        reason_from_response(status.suspension_reason)
                            .map(|reason| ContractSuspension { until, reason })
                    })
                    .transpose()?;
                // The warnings are read only when the warning list was asked for: an empty
                // list on the wire says "none" for a list read and nothing for one not read.
                let warnings = if lists.contains(&ContractModerationList::Warnings) {
                    warnings_from_response(status.warnings)?
                } else {
                    vec![]
                };
                Some(ContractModerationListStatuses::from_status(
                    &lists,
                    &ContractModerationStatus {
                        ban,
                        suspension,
                        warnings,
                    },
                ))
            }
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract moderation status, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((status, metadata))
    }
}

impl FromUnproved<platform::GetContractModerationEntriesRequest> for ContractModerationEntries {
    type Request = platform::GetContractModerationEntriesRequest;
    type Response = platform::GetContractModerationEntriesResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_moderation_entries_response::get_contract_moderation_entries_response_v0::Result as V0Result;

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

        let platform::get_contract_moderation_entries_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let entries = match v0.result {
            Some(V0Result::Entries(entries)) => Some(entries_from_response(entries.entries)?),
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract moderation entries, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((entries, metadata))
    }
}

impl FromUnproved<platform::GetContractDocumentRemovalsRequest> for ContractDocumentRemovals {
    type Request = platform::GetContractDocumentRemovalsRequest;
    type Response = platform::GetContractDocumentRemovalsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_document_removals_response::get_contract_document_removals_response_v0::Result as V0Result;

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

        // The request bounds what the response may hold, so it is read back here too, under
        // the same rules the node applied.
        let platform::get_contract_document_removals_request::Version::V0(request_v0) =
            request.version.ok_or(Error::EmptyVersion)?;
        let query = removals_query_from_request(
            request_v0.document_type_name,
            request_v0.selection,
            platform_version,
        )?;

        let platform::get_contract_document_removals_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let removals = match v0.result {
            Some(V0Result::Removals(removals)) => {
                Some(removals_from_response(removals.removals, &query)?)
            }
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract document removals, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((removals, metadata))
    }
}

impl FromUnproved<platform::GetContractTeamActionsRequest> for ContractTeamActions {
    type Request = platform::GetContractTeamActionsRequest;
    type Response = platform::GetContractTeamActionsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_team_actions_response::get_contract_team_actions_response_v0::Result as V0Result;

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

        // The request bounds what the response may hold, so it is read back here too, under
        // the same rules the node applied.
        let platform::get_contract_team_actions_request::Version::V0(request_v0) =
            request.version.ok_or(Error::EmptyVersion)?;
        let query = team_actions_query_from_request(
            request_v0.status,
            request_v0.start_at_action_id,
            request_v0.count,
            platform_version,
        )?;

        let platform::get_contract_team_actions_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let actions = match v0.result {
            Some(V0Result::Actions(actions)) => {
                Some(team_actions_from_response(actions.actions, &query)?)
            }
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract team actions, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((actions, metadata))
    }
}

impl FromUnproved<platform::GetContractTeamActionSignersRequest> for ContractTeamActionSigners {
    type Request = platform::GetContractTeamActionSignersRequest;
    type Response = platform::GetContractTeamActionSignersResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_team_action_signers_response::get_contract_team_action_signers_response_v0::Result as V0Result;

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

        let platform::get_contract_team_action_signers_request::Version::V0(request_v0) =
            request.version.ok_or(Error::EmptyVersion)?;
        team_action_status_from_request(request_v0.status)?;

        let platform::get_contract_team_action_signers_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let signers = match v0.result {
            Some(V0Result::Signers(signers)) => {
                Some(team_action_signers_from_response(signers.signer_ids)?)
            }
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract team action signers, got a proof"
                        .to_string(),
                })
            }
            None => None,
        };

        Ok((signers, metadata))
    }
}

impl FromUnproved<platform::GetContractModerationActionCountsRequest>
    for ContractModerationActionCounts
{
    type Request = platform::GetContractModerationActionCountsRequest;
    type Response = platform::GetContractModerationActionCountsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        let response: Self::Response = response.into();
        let platform::get_contract_moderation_action_counts_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let counts = match v0.result {
            Some(ModerationActionCountsResult::Counts(counts)) => {
                Some(moderation_action_counts_from_response(counts.counts)?)
            }
            Some(ModerationActionCountsResult::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract moderation action counts, got a proof"
                        .to_string(),
                })
            }
            None => None,
        };

        Ok((counts, metadata))
    }
}

impl FromUnproved<platform::GetContractFeePotsRequest> for ContractFeePots {
    type Request = platform::GetContractFeePotsRequest;
    type Response = platform::GetContractFeePotsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_fee_pots_response::get_contract_fee_pots_response_v0::Result as V0Result;

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

        let platform::get_contract_fee_pots_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let pots = match v0.result {
            Some(V0Result::Pots(pots)) => Some(fee_pots_from_response(pots)?),
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract fee pots, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((pots, metadata))
    }
}

impl FromUnproved<platform::GetIdentityKeysRemainingBudgetsRequest>
    for IdentityKeysRemainingBudgets
{
    type Request = platform::GetIdentityKeysRemainingBudgetsRequest;
    type Response = platform::GetIdentityKeysRemainingBudgetsResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_identity_keys_remaining_budgets_response::get_identity_keys_remaining_budgets_response_v0::Result as V0Result;

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

        let platform::get_identity_keys_remaining_budgets_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let budgets = match v0.result {
            Some(V0Result::KeysRemainingBudgets(budgets)) => Some(
                budgets
                    .entries
                    .into_iter()
                    .map(|entry| (entry.key_id, entry.remaining_budget))
                    .collect(),
            ),
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved remaining budgets, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((budgets, metadata))
    }
}

impl FromUnproved<platform::GetContractGroupMembersRequest> for ContractGroupMembersPage {
    type Request = platform::GetContractGroupMembersRequest;
    type Response = platform::GetContractGroupMembersResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        let request: Self::Request = request.into();
        let response: Self::Response = response.into();

        let platform::get_contract_group_members_request::Version::V0(request_v0) =
            request.version.ok_or(Error::EmptyVersion)?;
        let query = members_query_from_request(request_v0.members)?;

        let platform::get_contract_group_members_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let page = v0
            .result
            .map(|result| members_page_from_response(&query, result))
            .transpose()?;

        Ok((page, metadata))
    }
}

impl FromUnproved<platform::GetContractGroupsForContractRequest>
    for ContractGroupMembershipsForContract
{
    type Request = platform::GetContractGroupsForContractRequest;
    type Response = platform::GetContractGroupsForContractResponse;

    fn maybe_from_unproved_with_metadata<I: Into<Self::Request>, O: Into<Self::Response>>(
        _request: I,
        response: O,
        _network: Network,
        _platform_version: &PlatformVersion,
    ) -> Result<(Option<Self>, ResponseMetadata), Error>
    where
        Self: Sized,
    {
        use platform::get_contract_groups_for_contract_response::get_contract_groups_for_contract_response_v0::Result as V0Result;

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

        let platform::get_contract_groups_for_contract_response::Version::V0(v0) =
            response.version.ok_or(Error::EmptyVersion)?;
        let metadata = v0.metadata.ok_or(Error::EmptyResponseMetadata)?;

        let memberships = match v0.result {
            Some(V0Result::ContractGroupMemberships(memberships)) => {
                Some(memberships_from_response(memberships)?)
            }
            Some(V0Result::Proof(_)) => {
                return Err(Error::ResponseDecodeError {
                    error: "expected unproved contract group memberships, got a proof".to_string(),
                })
            }
            None => None,
        };

        Ok((memberships, metadata))
    }
}

#[cfg(test)]
mod contract_groups_tests {
    use super::*;
    use crate::types::contract_groups::{ContractGroupMembersQuery, ContractGroupOwner};
    use dapi_grpc::platform::v0::get_contract_group_info_response::{
        get_contract_group_info_response_v0::Result as InfoResult,
        ContractGroupInfo as ContractGroupInfoProto, GetContractGroupInfoResponseV0,
        Version as InfoVersion,
    };
    use dapi_grpc::platform::v0::get_contract_group_members_request::get_contract_group_members_request_v0::Members;
    use dapi_grpc::platform::v0::get_contract_group_members_request::{
        ContractMembersQuery, GetContractGroupMembersRequestV0, TokenMembersQuery,
        Version as MembersRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_group_members_response::{
        get_contract_group_members_response_v0::Result as MembersResult, ContractMembers,
        GetContractGroupMembersResponseV0, TokenMembers, Version as MembersVersion,
    };
    use dapi_grpc::platform::v0::get_contract_groups_for_contract_response::{
        get_contract_groups_for_contract_response_v0::Result as MembershipsResult,
        ContractGroupMemberships, DocumentTypeMemberships, GetContractGroupsForContractResponseV0,
        TokenMemberships, Version as MembershipsVersion,
    };
    use dapi_grpc::platform::v0::ContractGroupTokenMember;
    use std::collections::BTreeSet;

    fn info_response(result: Option<InfoResult>) -> platform::GetContractGroupInfoResponse {
        platform::GetContractGroupInfoResponse {
            version: Some(InfoVersion::V0(GetContractGroupInfoResponseV0 {
                result,
                metadata: Some(ResponseMetadata::default()),
            })),
        }
    }

    fn parse_info(
        response: platform::GetContractGroupInfoResponse,
    ) -> Result<Option<ContractGroupInfo>, Error> {
        <ContractGroupInfo as FromUnproved<platform::GetContractGroupInfoRequest>>::maybe_from_unproved(
            platform::GetContractGroupInfoRequest::default(),
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
    }

    #[test]
    fn info_with_no_admins_is_a_single_owner() {
        let info = parse_info(info_response(Some(InfoResult::ContractGroupInfo(
            ContractGroupInfoProto {
                owner_id: vec![1; 32],
                admin_ids: vec![],
                name: Some("alpha".to_string()),
                description: None,
            },
        ))))
        .expect("parse")
        .expect("present");

        assert_eq!(
            info.owner(),
            &ContractGroupOwner::SingleOwner(Identifier::new([1; 32]))
        );
        assert_eq!(info.name(), Some("alpha"));
        assert_eq!(info.description(), None);
    }

    #[test]
    fn info_with_admins_is_an_owner_and_admins() {
        let info = parse_info(info_response(Some(InfoResult::ContractGroupInfo(
            ContractGroupInfoProto {
                owner_id: vec![1; 32],
                admin_ids: vec![vec![3; 32], vec![2; 32]],
                name: None,
                description: Some("shared".to_string()),
            },
        ))))
        .expect("parse")
        .expect("present");

        assert_eq!(
            info.owner(),
            &ContractGroupOwner::OwnerAndAdmins {
                owner: Identifier::new([1; 32]),
                admins: BTreeSet::from([Identifier::new([2; 32]), Identifier::new([3; 32])]),
            }
        );
        assert_eq!(info.description(), Some("shared"));
    }

    #[test]
    fn info_absent_group_and_bad_owner_and_proof() {
        assert_eq!(parse_info(info_response(None)).expect("parse"), None);

        let err = parse_info(info_response(Some(InfoResult::ContractGroupInfo(
            ContractGroupInfoProto {
                owner_id: vec![1; 4],
                admin_ids: vec![],
                name: None,
                description: None,
            },
        ))))
        .unwrap_err();
        assert!(
            matches!(err, Error::ProtocolError { .. }),
            "a malformed response field is the node's error: {err:?}"
        );

        let err = parse_info(info_response(Some(InfoResult::Proof(
            platform::Proof::default(),
        ))))
        .unwrap_err();
        assert!(
            matches!(err, Error::ResponseDecodeError { .. }),
            "got: {err:?}"
        );
    }

    fn members_request(members: Members) -> platform::GetContractGroupMembersRequest {
        platform::GetContractGroupMembersRequest {
            version: Some(MembersRequestVersion::V0(
                GetContractGroupMembersRequestV0 {
                    contract_group_id: vec![1; 32],
                    members: Some(members),
                    limit: None,
                    prove: false,
                },
            )),
        }
    }

    fn members_response(
        result: Option<MembersResult>,
    ) -> platform::GetContractGroupMembersResponse {
        platform::GetContractGroupMembersResponse {
            version: Some(MembersVersion::V0(GetContractGroupMembersResponseV0 {
                result,
                metadata: Some(ResponseMetadata::default()),
            })),
        }
    }

    fn parse_members(
        request: platform::GetContractGroupMembersRequest,
        response: platform::GetContractGroupMembersResponse,
    ) -> Result<Option<ContractGroupMembersPage>, Error> {
        <ContractGroupMembersPage as FromUnproved<platform::GetContractGroupMembersRequest>>::maybe_from_unproved(
            request,
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
    }

    #[test]
    fn members_page_of_the_requested_kind_is_read() {
        let page = parse_members(
            members_request(Members::Tokens(TokenMembersQuery { start_after: None })),
            members_response(Some(MembersResult::Tokens(TokenMembers {
                tokens: vec![ContractGroupTokenMember {
                    contract_id: vec![5; 32],
                    token_position: 2,
                }],
            }))),
        )
        .expect("parse")
        .expect("present");

        assert_eq!(
            page,
            ContractGroupMembersPage::Tokens(vec![(Identifier::new([5; 32]), 2)])
        );
        assert_eq!(
            page.next_query(),
            Some(ContractGroupMembersQuery::Tokens {
                start_after: Some((Identifier::new([5; 32]), 2)),
            })
        );
    }

    #[test]
    fn members_page_of_another_kind_is_rejected() {
        let err = parse_members(
            members_request(Members::Contracts(ContractMembersQuery {
                start_after: None,
            })),
            members_response(Some(MembersResult::Tokens(TokenMembers::default()))),
        )
        .unwrap_err();
        assert!(
            matches!(err, Error::ResponseDecodeError { .. }),
            "got: {err:?}"
        );

        let err = parse_members(
            members_request(Members::Contracts(ContractMembersQuery {
                start_after: None,
            })),
            members_response(Some(MembersResult::Proof(platform::Proof::default()))),
        )
        .unwrap_err();
        assert!(
            matches!(err, Error::ResponseDecodeError { .. }),
            "got: {err:?}"
        );
    }

    #[test]
    fn members_page_contracts_are_read_in_order() {
        let page = parse_members(
            members_request(Members::Contracts(ContractMembersQuery {
                start_after: None,
            })),
            members_response(Some(MembersResult::Contracts(ContractMembers {
                contract_ids: vec![vec![1; 32], vec![2; 32]],
            }))),
        )
        .expect("parse")
        .expect("present");

        assert_eq!(
            page,
            ContractGroupMembersPage::Contracts(vec![
                Identifier::new([1; 32]),
                Identifier::new([2; 32])
            ])
        );
    }

    #[test]
    fn memberships_are_read_into_sets() {
        let response = platform::GetContractGroupsForContractResponse {
            version: Some(MembershipsVersion::V0(
                GetContractGroupsForContractResponseV0 {
                    result: Some(MembershipsResult::ContractGroupMemberships(
                        ContractGroupMemberships {
                            contract_group_ids: vec![vec![1; 32]],
                            document_types: vec![DocumentTypeMemberships {
                                document_type_name: "note".to_string(),
                                contract_group_ids: vec![vec![2; 32], vec![1; 32]],
                            }],
                            tokens: vec![TokenMemberships {
                                token_position: 7,
                                contract_group_ids: vec![vec![3; 32]],
                            }],
                        },
                    )),
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };

        let memberships = <ContractGroupMembershipsForContract as FromUnproved<
            platform::GetContractGroupsForContractRequest,
        >>::maybe_from_unproved(
            platform::GetContractGroupsForContractRequest::default(),
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
        .expect("parse")
        .expect("present");

        assert_eq!(
            memberships.contract,
            BTreeSet::from([Identifier::new([1; 32])])
        );
        assert_eq!(
            memberships.document_types["note"],
            BTreeSet::from([Identifier::new([1; 32]), Identifier::new([2; 32])])
        );
        assert_eq!(
            memberships.tokens[&7],
            BTreeSet::from([Identifier::new([3; 32])])
        );
        assert_eq!(
            memberships.all_contract_group_ids(),
            BTreeSet::from([
                Identifier::new([1; 32]),
                Identifier::new([2; 32]),
                Identifier::new([3; 32])
            ])
        );
    }
}

#[cfg(test)]
mod contract_moderation_tests {
    use super::*;
    use crate::types::contract_moderation::ContractModerationReason;
    use dapi_grpc::platform::v0::get_contract_document_removals_request::get_contract_document_removals_request_v0::Selection as RemovalsSelection;
    use dapi_grpc::platform::v0::get_contract_document_removals_request::{
        DocumentIds as RemovalsDocumentIds, GetContractDocumentRemovalsRequestV0,
        Page as RemovalsPage, Version as RemovalsRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_document_removals_response::{
        get_contract_document_removals_response_v0::Result as RemovalsResult,
        ContractDocumentRemoval as ContractDocumentRemovalProto,
        ContractDocumentRemovals as ContractDocumentRemovalsProto,
        GetContractDocumentRemovalsResponseV0, Version as RemovalsResponseVersion,
    };
    use dapi_grpc::platform::v0::get_contract_moderation_status_request::{
        GetContractModerationStatusRequestV0, Version as StatusRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_moderation_status_response::{
        get_contract_moderation_status_response_v0::Result as StatusResult,
        ContractModerationStatus as ContractModerationStatusProto,
        GetContractModerationStatusResponseV0, Version as StatusResponseVersion,
    };
    use dapi_grpc::platform::v0::get_contract_team_action_signers_request::{
        GetContractTeamActionSignersRequestV0, Version as SignersRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_team_action_signers_response::{
        get_contract_team_action_signers_response_v0::Result as SignersResult,
        ContractTeamActionSigners as ContractTeamActionSignersProto,
        GetContractTeamActionSignersResponseV0, Version as SignersResponseVersion,
    };
    use dapi_grpc::platform::v0::get_contract_team_actions_request::{
        ActionStatus, GetContractTeamActionsRequestV0, Version as TeamActionsRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_team_actions_response::{
        contract_team_action, get_contract_team_actions_response_v0::Result as TeamActionsResult,
        ContractTeamAction as ContractTeamActionProto,
        ContractTeamActions as ContractTeamActionsProto, DeleteSettledDocument,
        GetContractTeamActionsResponseV0, Version as TeamActionsResponseVersion,
    };
    use dapi_grpc::platform::v0::get_contract_moderation_action_counts_request::{
        GetContractModerationActionCountsRequestV0, Version as CountsRequestVersion,
    };
    use dapi_grpc::platform::v0::get_contract_moderation_action_counts_response::{
        ContractModerationActionCount, ContractModerationActionCounts as CountsProto,
        GetContractModerationActionCountsResponseV0, Version as CountsResponseVersion,
    };
    use dapi_grpc::platform::v0::ContractModerationReason as ContractModerationReasonProto;
    use dapi_grpc::platform::v0::ContractWarning as ContractWarningProto;
    use dapi_grpc::platform::v0::ResponseMetadata;
    use dpp::dashcore::Network;
    use dpp::version::PlatformVersion;

    const BANLIST: i32 = 1;
    const SUSPENSIONS: i32 = 2;
    const WARNINGS: i32 = 3;

    fn status(
        requested: Vec<i32>,
        response: ContractModerationStatusProto,
    ) -> Result<Option<ContractModerationListStatuses>, Error> {
        let request = platform::GetContractModerationStatusRequest {
            version: Some(StatusRequestVersion::V0(
                GetContractModerationStatusRequestV0 {
                    contract_id: vec![1; 32],
                    identity_id: vec![2; 32],
                    lists: requested,
                    prove: false,
                },
            )),
        };
        let response = platform::GetContractModerationStatusResponse {
            version: Some(StatusResponseVersion::V0(
                GetContractModerationStatusResponseV0 {
                    result: Some(StatusResult::Status(response)),
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };
        ContractModerationListStatuses::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
        .map(|(status, _)| status)
    }

    #[test]
    fn should_report_the_lists_the_response_covers() {
        let statuses = status(
            vec![BANLIST, SUSPENSIONS],
            ContractModerationStatusProto {
                banned: Some(true),
                suspended_until: Some(7),
                lists: vec![BANLIST, SUSPENSIONS],
                ban_reason: Some(ContractModerationReasonProto {
                    code: None,
                    text: "spam".to_string(),
                    documents: vec![],
                    reason_document_id: None,
                }),
                suspension_reason: Some(ContractModerationReasonProto {
                    code: Some(9),
                    text: "flooding".to_string(),
                    documents: vec![],
                    reason_document_id: None,
                }),
                warnings: vec![],
            },
        )
        .expect("expected the status to convert")
        .expect("expected a status");

        assert_eq!(statuses.banned(), Some(true));
        assert_eq!(statuses.suspended_until(), Some(Some(7)));
        // The warning list was not asked for, so nothing is said about it.
        assert_eq!(statuses.warnings(), None);
        assert_eq!(
            statuses.ban().flatten().map(|ban| &ban.reason),
            Some(&ContractModerationReason::from_text("spam"))
        );
        assert_eq!(
            statuses.suspension().flatten().map(|entry| &entry.reason),
            Some(&ContractModerationReason {
                code: Some(9),
                text: "flooding".to_string(),
                documents: vec![],
                reason_document_id: None,
            })
        );
    }

    #[test]
    fn should_refuse_an_entry_without_a_reason_or_with_a_code_past_u16() {
        let no_reason = status(
            vec![BANLIST],
            ContractModerationStatusProto {
                banned: Some(true),
                lists: vec![BANLIST],
                ..Default::default()
            },
        );
        assert!(matches!(no_reason, Err(Error::ResponseDecodeError { .. })));

        let wide_code = status(
            vec![SUSPENSIONS],
            ContractModerationStatusProto {
                suspended_until: Some(7),
                lists: vec![SUSPENSIONS],
                suspension_reason: Some(ContractModerationReasonProto {
                    code: Some(u16::MAX as u32 + 1),
                    text: String::new(),
                    documents: vec![],
                    reason_document_id: None,
                }),
                ..Default::default()
            },
        );
        assert!(matches!(wide_code, Err(Error::ResponseDecodeError { .. })));

        // A clean identity has no reason to give.
        let clean = status(
            vec![BANLIST, SUSPENSIONS],
            ContractModerationStatusProto {
                banned: Some(false),
                lists: vec![BANLIST, SUSPENSIONS],
                ..Default::default()
            },
        )
        .expect("expected the status to convert")
        .expect("expected a status");
        assert_eq!(clean.ban(), Some(None));
        assert_eq!(clean.suspension(), Some(None));
    }

    #[test]
    fn should_read_the_warnings_when_the_warning_list_was_asked_for() {
        let warning = |warned_at: u64, text: &str| ContractWarningProto {
            warned_at,
            reason: Some(ContractModerationReasonProto {
                code: None,
                text: text.to_string(),
                documents: vec![],
                reason_document_id: None,
            }),
        };
        let warned = status(
            vec![WARNINGS],
            ContractModerationStatusProto {
                lists: vec![WARNINGS],
                warnings: vec![warning(5, "first strike"), warning(6, "second strike")],
                ..Default::default()
            },
        )
        .expect("expected the status to convert")
        .expect("expected a status");
        let warnings = warned.warnings().expect("expected the warning list");
        assert_eq!(warnings.len(), 2);
        assert_eq!(warnings[1].warned_at, 6);
        assert_eq!(warnings[1].reason.text, "second strike");
        assert_eq!(warned.banned(), None);

        // No warnings on a list that was read: none, not unknown.
        let clean = status(
            vec![WARNINGS],
            ContractModerationStatusProto {
                lists: vec![WARNINGS],
                ..Default::default()
            },
        )
        .expect("expected the status to convert")
        .expect("expected a status");
        assert_eq!(clean.warnings(), Some(&[][..]));

        // A warning without a reason is refused like an entry without one.
        let no_reason = status(
            vec![WARNINGS],
            ContractModerationStatusProto {
                lists: vec![WARNINGS],
                warnings: vec![ContractWarningProto {
                    warned_at: 5,
                    reason: None,
                }],
                ..Default::default()
            },
        );
        assert!(matches!(no_reason, Err(Error::ResponseDecodeError { .. })));
    }

    #[test]
    fn should_refuse_a_status_that_does_not_cover_a_list_asked_for() {
        // The banlist was asked for and the response does not say it was read: reporting "not
        // banned" would be a guess.
        let uncovered = status(
            vec![BANLIST, SUSPENSIONS],
            ContractModerationStatusProto {
                lists: vec![SUSPENSIONS],
                ..Default::default()
            },
        );
        assert!(matches!(uncovered, Err(Error::ResponseDecodeError { .. })));

        let covered_but_unset = status(
            vec![BANLIST],
            ContractModerationStatusProto {
                lists: vec![BANLIST],
                ..Default::default()
            },
        );
        assert!(matches!(
            covered_but_unset,
            Err(Error::ResponseDecodeError { .. })
        ));
    }

    fn removals(
        selection: Option<RemovalsSelection>,
        result: Option<RemovalsResult>,
    ) -> Result<Option<ContractDocumentRemovals>, Error> {
        let request = platform::GetContractDocumentRemovalsRequest {
            version: Some(RemovalsRequestVersion::V0(
                GetContractDocumentRemovalsRequestV0 {
                    contract_id: vec![1; 32],
                    document_type_name: "post".to_string(),
                    selection,
                    prove: false,
                },
            )),
        };
        let response = platform::GetContractDocumentRemovalsResponse {
            version: Some(RemovalsResponseVersion::V0(
                GetContractDocumentRemovalsResponseV0 {
                    result,
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };
        ContractDocumentRemovals::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
        .map(|(removals, _)| removals)
    }

    fn removal_proto(seed: u8) -> ContractDocumentRemovalProto {
        ContractDocumentRemovalProto {
            document_id: vec![seed; 32],
            document_owner_id: vec![seed + 0x10; 32],
            moderator_id: vec![0x77; 32],
            removed_at: 1_000 + u64::from(seed),
            document_hash: vec![seed + 0x20; 32],
            restoration: None,
            reason: Some(ContractModerationReasonProto {
                code: None,
                text: "spam".to_string(),
                documents: vec![],
                reason_document_id: None,
            }),
            kept_fields: Default::default(),
        }
    }

    #[test]
    fn should_read_the_removals_the_request_asked_for() {
        let page = Some(RemovalsSelection::Page(RemovalsPage {
            start_after: None,
            limit: Some(2),
        }));
        let read = removals(
            page.clone(),
            Some(RemovalsResult::Removals(ContractDocumentRemovalsProto {
                removals: vec![removal_proto(1), removal_proto(2)],
            })),
        )
        .expect("expected the removals to convert")
        .expect("expected removals");
        assert_eq!(read.removals().len(), 2);
        assert_eq!(read.removals()[0].document_id, Identifier::from([1; 32]));
        assert_eq!(
            read.removals()[1].removal.moderator_id,
            Identifier::from([0x77; 32])
        );

        // A page of more records than the request allowed, and a request that selects nothing.
        let over_limit = removals(
            Some(RemovalsSelection::Page(RemovalsPage {
                start_after: None,
                limit: Some(1),
            })),
            Some(RemovalsResult::Removals(ContractDocumentRemovalsProto {
                removals: vec![removal_proto(1), removal_proto(2)],
            })),
        );
        assert!(matches!(over_limit, Err(Error::ResponseDecodeError { .. })));
        assert!(matches!(
            removals(None, None),
            Err(Error::RequestError { .. })
        ));

        // The unproved path never reads a proof.
        let proved = removals(page, Some(RemovalsResult::Proof(Default::default())));
        assert!(matches!(proved, Err(Error::ResponseDecodeError { .. })));
    }

    #[test]
    fn should_refuse_a_removal_of_a_document_the_request_did_not_name() {
        let by_ids = Some(RemovalsSelection::DocumentIds(RemovalsDocumentIds {
            document_ids: vec![vec![1; 32], vec![3; 32]],
        }));
        let unasked = removals(
            by_ids.clone(),
            Some(RemovalsResult::Removals(ContractDocumentRemovalsProto {
                removals: vec![removal_proto(2)],
            })),
        );
        assert!(matches!(unasked, Err(Error::ResponseDecodeError { .. })));

        // An id with no record is simply left out, which is an answer.
        let partial = removals(
            by_ids,
            Some(RemovalsResult::Removals(ContractDocumentRemovalsProto {
                removals: vec![removal_proto(1)],
            })),
        )
        .expect("expected the removals to convert")
        .expect("expected removals");
        assert_eq!(partial.removals().len(), 1);
    }

    fn team_actions(
        count: Option<u32>,
        result: Option<TeamActionsResult>,
    ) -> Result<Option<ContractTeamActions>, Error> {
        let request = platform::GetContractTeamActionsRequest {
            version: Some(TeamActionsRequestVersion::V0(
                GetContractTeamActionsRequestV0 {
                    contract_id: vec![1; 32],
                    status: ActionStatus::Active as i32,
                    start_at_action_id: None,
                    count,
                    prove: false,
                },
            )),
        };
        let response = platform::GetContractTeamActionsResponse {
            version: Some(TeamActionsResponseVersion::V0(
                GetContractTeamActionsResponseV0 {
                    result,
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };
        ContractTeamActions::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
        .map(|(actions, _)| actions)
    }

    fn team_action_proto(seed: u8) -> ContractTeamActionProto {
        ContractTeamActionProto {
            action_id: vec![seed; 32],
            proposer_id: vec![0x77; 32],
            proposed_at: 1_000,
            event: Some(contract_team_action::Event::DeleteSettledDocument(
                DeleteSettledDocument {
                    document_type_name: "post".to_string(),
                    document_id: vec![seed + 0x10; 32],
                    document_last_modified_at: 10,
                    document_revision: Some(2),
                    reason: Some(ContractModerationReasonProto {
                        code: None,
                        text: "doxxing".to_string(),
                        documents: vec![],
                        reason_document_id: None,
                    }),
                },
            )),
            approval_count: u32::from(seed),
        }
    }

    #[test]
    fn should_read_the_team_actions_the_request_asked_for() {
        let read = team_actions(
            Some(2),
            Some(TeamActionsResult::Actions(ContractTeamActionsProto {
                actions: vec![team_action_proto(1), team_action_proto(2)],
            })),
        )
        .expect("expected the team actions to convert")
        .expect("expected team actions");
        assert_eq!(read.actions().len(), 2);
        assert_eq!(read.actions()[0].action_id, Identifier::from([1; 32]));
        assert_eq!(
            read.actions()[0].action.proposer_id,
            Identifier::from([0x77; 32])
        );

        // More actions than the page holds, a missing result and a proof are refused or empty
        team_actions(
            Some(1),
            Some(TeamActionsResult::Actions(ContractTeamActionsProto {
                actions: vec![team_action_proto(1), team_action_proto(2)],
            })),
        )
        .expect_err("expected a page too long to be refused");
        assert_eq!(team_actions(None, None).expect("expected no error"), None);
        team_actions(None, Some(TeamActionsResult::Proof(Default::default())))
            .expect_err("expected a proof to be refused");
    }

    #[test]
    fn should_read_the_signers_of_a_team_action() {
        let request = platform::GetContractTeamActionSignersRequest {
            version: Some(SignersRequestVersion::V0(
                GetContractTeamActionSignersRequestV0 {
                    contract_id: vec![1; 32],
                    status: ActionStatus::Closed as i32,
                    action_id: vec![2; 32],
                    prove: false,
                },
            )),
        };
        let response = platform::GetContractTeamActionSignersResponse {
            version: Some(SignersResponseVersion::V0(
                GetContractTeamActionSignersResponseV0 {
                    result: Some(SignersResult::Signers(ContractTeamActionSignersProto {
                        signer_ids: vec![vec![3; 32], vec![4; 32]],
                    })),
                    metadata: Some(ResponseMetadata::default()),
                },
            )),
        };
        let (signers, _) = ContractTeamActionSigners::maybe_from_unproved_with_metadata(
            request,
            response,
            Network::Testnet,
            PlatformVersion::latest(),
        )
        .expect("expected the signers to convert");
        assert_eq!(
            signers.expect("expected signers").signers(),
            &[Identifier::from([3; 32]), Identifier::from([4; 32])]
        );
    }

    #[test]
    fn should_read_the_moderation_action_counts_of_a_contract() {
        let counts = |result: Option<ModerationActionCountsResult>| {
            ContractModerationActionCounts::maybe_from_unproved_with_metadata(
                platform::GetContractModerationActionCountsRequest {
                    version: Some(CountsRequestVersion::V0(
                        GetContractModerationActionCountsRequestV0 {
                            contract_id: vec![1; 32],
                            prove: false,
                        },
                    )),
                },
                platform::GetContractModerationActionCountsResponse {
                    version: Some(CountsResponseVersion::V0(
                        GetContractModerationActionCountsResponseV0 {
                            result,
                            metadata: Some(ResponseMetadata::default()),
                        },
                    )),
                },
                Network::Testnet,
                PlatformVersion::latest(),
            )
            .map(|(counts, _)| counts)
        };
        assert_eq!(
            counts(Some(ModerationActionCountsResult::Counts(CountsProto {
                counts: vec![ContractModerationActionCount {
                    identity_id: vec![3; 32],
                    count: 7,
                }],
            })))
            .expect("expected the counts to convert")
            .expect("expected counts")
            .counts(),
            &BTreeMap::from([(Identifier::from([3; 32]), 7)])
        );
        assert_eq!(counts(None).expect("expected no error"), None);
        counts(Some(
            ModerationActionCountsResult::Proof(Default::default()),
        ))
        .expect_err("expected a proof to be refused");
    }
}