nym-validator-client 1.21.4

// Copyright 2026 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0

use crate::collect_paged;
use crate::nyxd::contract_traits::NymContractsProvider;
use crate::nyxd::error::NyxdError;
use crate::nyxd::CosmWasmClient;
use async_trait::async_trait;
use cosmrs::AccountId;
use nym_mixnet_contract_common::NodeId;
use serde::Deserialize;

pub use nym_node_families_contract_common::{
    msg::QueryMsg as NodeFamiliesQueryMsg, AllFamilyMembersPagedResponse,
    AllPastFamilyInvitationsPagedResponse, Config, FamiliesPagedResponse, FamilyMemberRecord,
    FamilyMembersPagedResponse, GlobalPastFamilyInvitationCursor, NodeFamily,
    NodeFamilyByNameResponse, NodeFamilyByOwnerResponse, NodeFamilyId,
    NodeFamilyMembershipResponse, NodeFamilyResponse, PastFamilyInvitation,
    PastFamilyInvitationCursor, PastFamilyInvitationForNodeCursor,
    PastFamilyInvitationsForNodePagedResponse, PastFamilyInvitationsPagedResponse,
    PastFamilyMember, PastFamilyMemberCursor, PastFamilyMemberForNodeCursor,
    PastFamilyMembersForNodePagedResponse, PastFamilyMembersPagedResponse,
    PendingFamilyInvitationDetails, PendingFamilyInvitationResponse,
    PendingFamilyInvitationsPagedResponse, PendingInvitationsForNodePagedResponse,
    PendingInvitationsPagedResponse,
};

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
pub trait NodeFamiliesQueryClient {
    async fn query_node_families_contract<T>(
        &self,
        query: NodeFamiliesQueryMsg,
    ) -> Result<T, NyxdError>
    where
        for<'a> T: Deserialize<'a>;

    async fn get_config(&self) -> Result<Config, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetConfig {})
            .await
    }

    async fn get_family_by_id(
        &self,
        family_id: NodeFamilyId,
    ) -> Result<NodeFamilyResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamilyById { family_id })
            .await
    }

    async fn get_family_by_owner(
        &self,
        owner: &AccountId,
    ) -> Result<NodeFamilyByOwnerResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamilyByOwner {
            owner: owner.to_string(),
        })
        .await
    }

    async fn get_family_by_name(
        &self,
        name: String,
    ) -> Result<NodeFamilyByNameResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamilyByName { name })
            .await
    }

    async fn get_families_paged(
        &self,
        start_after: Option<NodeFamilyId>,
        limit: Option<u32>,
    ) -> Result<FamiliesPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamiliesPaged {
            start_after,
            limit,
        })
        .await
    }

    async fn get_family_membership(
        &self,
        node_id: NodeId,
    ) -> Result<NodeFamilyMembershipResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamilyMembership { node_id })
            .await
    }

    async fn get_family_members_paged(
        &self,
        family_id: NodeFamilyId,
        start_after: Option<NodeId>,
        limit: Option<u32>,
    ) -> Result<FamilyMembersPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetFamilyMembersPaged {
            family_id,
            start_after,
            limit,
        })
        .await
    }

    async fn get_all_family_members_paged(
        &self,
        start_after: Option<NodeId>,
        limit: Option<u32>,
    ) -> Result<AllFamilyMembersPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetAllFamilyMembersPaged {
            start_after,
            limit,
        })
        .await
    }

    async fn get_pending_invitation(
        &self,
        family_id: NodeFamilyId,
        node_id: NodeId,
    ) -> Result<PendingFamilyInvitationResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPendingInvitation {
            family_id,
            node_id,
        })
        .await
    }

    async fn get_pending_invitations_for_family_paged(
        &self,
        family_id: NodeFamilyId,
        start_after: Option<NodeId>,
        limit: Option<u32>,
    ) -> Result<PendingFamilyInvitationsPagedResponse, NyxdError> {
        self.query_node_families_contract(
            NodeFamiliesQueryMsg::GetPendingInvitationsForFamilyPaged {
                family_id,
                start_after,
                limit,
            },
        )
        .await
    }

    async fn get_pending_invitations_for_node_paged(
        &self,
        node_id: NodeId,
        start_after: Option<NodeFamilyId>,
        limit: Option<u32>,
    ) -> Result<PendingInvitationsForNodePagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPendingInvitationsForNodePaged {
            node_id,
            start_after,
            limit,
        })
        .await
    }

    async fn get_all_pending_invitations_paged(
        &self,
        start_after: Option<(NodeFamilyId, NodeId)>,
        limit: Option<u32>,
    ) -> Result<PendingInvitationsPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetAllPendingInvitationsPaged {
            start_after,
            limit,
        })
        .await
    }

    async fn get_past_invitations_for_family_paged(
        &self,
        family_id: NodeFamilyId,
        start_after: Option<PastFamilyInvitationCursor>,
        limit: Option<u32>,
    ) -> Result<PastFamilyInvitationsPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPastInvitationsForFamilyPaged {
            family_id,
            start_after,
            limit,
        })
        .await
    }

    async fn get_past_invitations_for_node_paged(
        &self,
        node_id: NodeId,
        start_after: Option<PastFamilyInvitationForNodeCursor>,
        limit: Option<u32>,
    ) -> Result<PastFamilyInvitationsForNodePagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPastInvitationsForNodePaged {
            node_id,
            start_after,
            limit,
        })
        .await
    }

    async fn get_all_past_invitations_paged(
        &self,
        start_after: Option<GlobalPastFamilyInvitationCursor>,
        limit: Option<u32>,
    ) -> Result<AllPastFamilyInvitationsPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetAllPastInvitationsPaged {
            start_after,
            limit,
        })
        .await
    }

    async fn get_past_members_for_family_paged(
        &self,
        family_id: NodeFamilyId,
        start_after: Option<PastFamilyMemberCursor>,
        limit: Option<u32>,
    ) -> Result<PastFamilyMembersPagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPastMembersForFamilyPaged {
            family_id,
            start_after,
            limit,
        })
        .await
    }

    async fn get_past_members_for_node_paged(
        &self,
        node_id: NodeId,
        start_after: Option<PastFamilyMemberForNodeCursor>,
        limit: Option<u32>,
    ) -> Result<PastFamilyMembersForNodePagedResponse, NyxdError> {
        self.query_node_families_contract(NodeFamiliesQueryMsg::GetPastMembersForNodePaged {
            node_id,
            start_after,
            limit,
        })
        .await
    }
}

// extension trait to the query client to deal with the paged queries
// (it didn't feel appropriate to combine it with the existing trait)
#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
pub trait PagedNodeFamiliesQueryClient: NodeFamiliesQueryClient {
    async fn get_all_families(&self) -> Result<Vec<NodeFamily>, NyxdError> {
        collect_paged!(self, get_families_paged, families)
    }

    async fn get_all_family_members_for_family(
        &self,
        family_id: NodeFamilyId,
    ) -> Result<Vec<FamilyMemberRecord>, NyxdError> {
        collect_paged!(self, get_family_members_paged, members, family_id)
    }

    async fn get_all_family_members(&self) -> Result<Vec<FamilyMemberRecord>, NyxdError> {
        collect_paged!(self, get_all_family_members_paged, members)
    }

    async fn get_all_pending_invitations_for_family(
        &self,
        family_id: NodeFamilyId,
    ) -> Result<Vec<PendingFamilyInvitationDetails>, NyxdError> {
        collect_paged!(
            self,
            get_pending_invitations_for_family_paged,
            invitations,
            family_id
        )
    }

    async fn get_all_pending_invitations_for_node(
        &self,
        node_id: NodeId,
    ) -> Result<Vec<PendingFamilyInvitationDetails>, NyxdError> {
        collect_paged!(
            self,
            get_pending_invitations_for_node_paged,
            invitations,
            node_id
        )
    }

    async fn get_all_pending_invitations(
        &self,
    ) -> Result<Vec<PendingFamilyInvitationDetails>, NyxdError> {
        collect_paged!(self, get_all_pending_invitations_paged, invitations)
    }

    async fn get_all_past_invitations_for_family(
        &self,
        family_id: NodeFamilyId,
    ) -> Result<Vec<PastFamilyInvitation>, NyxdError> {
        collect_paged!(
            self,
            get_past_invitations_for_family_paged,
            invitations,
            family_id
        )
    }

    async fn get_all_past_invitations_for_node(
        &self,
        node_id: NodeId,
    ) -> Result<Vec<PastFamilyInvitation>, NyxdError> {
        collect_paged!(
            self,
            get_past_invitations_for_node_paged,
            invitations,
            node_id
        )
    }

    async fn get_all_past_invitations(&self) -> Result<Vec<PastFamilyInvitation>, NyxdError> {
        collect_paged!(self, get_all_past_invitations_paged, invitations)
    }

    async fn get_all_past_members_for_family(
        &self,
        family_id: NodeFamilyId,
    ) -> Result<Vec<PastFamilyMember>, NyxdError> {
        collect_paged!(self, get_past_members_for_family_paged, members, family_id)
    }

    async fn get_all_past_members_for_node(
        &self,
        node_id: NodeId,
    ) -> Result<Vec<PastFamilyMember>, NyxdError> {
        collect_paged!(self, get_past_members_for_node_paged, members, node_id)
    }
}

#[async_trait]
impl<T> PagedNodeFamiliesQueryClient for T where T: NodeFamiliesQueryClient {}

#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
impl<C> NodeFamiliesQueryClient for C
where
    C: CosmWasmClient + NymContractsProvider + Send + Sync,
{
    async fn query_node_families_contract<T>(
        &self,
        query: NodeFamiliesQueryMsg,
    ) -> Result<T, NyxdError>
    where
        for<'a> T: Deserialize<'a>,
    {
        let node_families_contract_address = &self
            .node_families_contract_address()
            .ok_or_else(|| NyxdError::unavailable_contract_address("node families contract"))?;
        self.query_contract_smart(node_families_contract_address, &query)
            .await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::nyxd::contract_traits::tests::IgnoreValue;
    use nym_node_families_contract_common::QueryMsg;

    // it's enough that this compiles and clippy is happy about it
    #[allow(dead_code)]
    fn all_query_variants_are_covered<C: NodeFamiliesQueryClient + Send + Sync>(
        client: C,
        msg: NodeFamiliesQueryMsg,
    ) {
        match msg {
            NodeFamiliesQueryMsg::GetConfig {} => client.get_config().ignore(),
            NodeFamiliesQueryMsg::GetFamilyById { family_id } => {
                client.get_family_by_id(family_id).ignore()
            }
            NodeFamiliesQueryMsg::GetFamilyByOwner { owner } => {
                client.get_family_by_owner(&owner.parse().unwrap()).ignore()
            }
            NodeFamiliesQueryMsg::GetFamilyByName { name } => {
                client.get_family_by_name(name).ignore()
            }
            NodeFamiliesQueryMsg::GetFamiliesPaged { start_after, limit } => {
                client.get_families_paged(start_after, limit).ignore()
            }
            NodeFamiliesQueryMsg::GetFamilyMembership { node_id } => {
                client.get_family_membership(node_id).ignore()
            }
            NodeFamiliesQueryMsg::GetFamilyMembersPaged {
                family_id,
                start_after,
                limit,
            } => client
                .get_family_members_paged(family_id, start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetAllFamilyMembersPaged { start_after, limit } => client
                .get_all_family_members_paged(start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetPendingInvitation { family_id, node_id } => {
                client.get_pending_invitation(family_id, node_id).ignore()
            }
            NodeFamiliesQueryMsg::GetPendingInvitationsForFamilyPaged {
                family_id,
                start_after,
                limit,
            } => client
                .get_pending_invitations_for_family_paged(family_id, start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetPendingInvitationsForNodePaged {
                node_id,
                start_after,
                limit,
            } => client
                .get_pending_invitations_for_node_paged(node_id, start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetAllPendingInvitationsPaged { start_after, limit } => client
                .get_all_pending_invitations_paged(start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetPastInvitationsForFamilyPaged {
                family_id,
                start_after,
                limit,
            } => client
                .get_past_invitations_for_family_paged(family_id, start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetPastInvitationsForNodePaged {
                node_id,
                start_after,
                limit,
            } => client
                .get_past_invitations_for_node_paged(node_id, start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetAllPastInvitationsPaged { start_after, limit } => client
                .get_all_past_invitations_paged(start_after, limit)
                .ignore(),
            NodeFamiliesQueryMsg::GetPastMembersForFamilyPaged {
                family_id,
                start_after,
                limit,
            } => client
                .get_past_members_for_family_paged(family_id, start_after, limit)
                .ignore(),
            QueryMsg::GetPastMembersForNodePaged {
                node_id,
                start_after,
                limit,
            } => client
                .get_past_members_for_node_paged(node_id, start_after, limit)
                .ignore(),
        };
    }
}