metrom_resolver_client/

lib.rs

use std::{
    collections::{HashMap, HashSet},
    fmt::Debug,
    num::ParseIntError,
    time::Duration,
};

use alloy::primitives::U256;
use chrono::NaiveDateTime;
use metrom_commons::{
    clients::get_retryable_http_client,
    types::{
        BlockNumberAndTimestamp, ByChainTypeAndId, address::Address, amm::Amm,
        amm_pool_id::AmmPoolId, amm_pool_liquidity_type::AmmPoolLiquidityType,
        chain_type::ChainType,
    },
};
use metrom_resolver_commons::{ResolveAmmPoolsQuery, ResolveTokensQuery};
use serde::{Deserialize, Serialize, de::DeserializeOwned};
use thiserror::Error;

// reexport this stuff
pub use metrom_resolver_commons::{
    AmmPool, GmxV1Collateral, LiquityV2Collateral, Token, TokenWithAddress,
};

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub struct PricedToken {
    /// Number of decimals the token uses
    pub decimals: i32,
    /// The symbol of the token
    pub symbol: String,
    /// The name of the token
    pub name: String,
    /// The USD price of the token
    pub usd_price: f64,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub struct AmmPoolWithTvl {
    /// The pool's dex
    pub dex: String,
    /// The pool's AMM
    pub amm: Amm,
    /// The pool's liquidity type
    pub liquidity_type: AmmPoolLiquidityType,
    /// The pool's tokens
    pub tokens: Vec<TokenWithAddress>,
    /// The pool's USD TVL
    pub usd_tvl: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// The pool's fee
    pub fee: Option<f64>,
}

#[derive(Serialize, Deserialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
pub struct AmmPoolWithTvlAndLiquidity {
    /// The pool's dex
    pub dex: String,
    /// The pool's AMM
    pub amm: Amm,
    /// The pool's liquidity type
    pub liquidity_type: AmmPoolLiquidityType,
    #[cfg_attr(feature = "utoipa", schema(value_type = String, example = "1655626"))]
    /// The pool's liquidity
    pub liquidity: U256,
    /// The pool's tokens
    pub tokens: Vec<TokenWithAddress>,
    /// The pool's USD TVL
    pub usd_tvl: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    /// The pool's fee
    pub fee: Option<f64>,
}

trait Selector: Serialize {
    fn is_empty(&self) -> bool;
}

impl<K: Serialize, V: Serialize> Selector for HashMap<K, V> {
    fn is_empty(&self) -> bool {
        self.is_empty()
    }
}

impl<T: Serialize> Selector for HashSet<T> {
    fn is_empty(&self) -> bool {
        self.is_empty()
    }
}

#[derive(Error, Debug)]
pub enum ResolveError {
    #[error("An error occurred while serializing the query string")]
    SerializeQuery(#[source] serde_qs::Error),
    #[error("An error occurred sending the resolve tokens request")]
    Network(#[source] reqwest_middleware::Error),
    #[error("Could not deserialize the given response")]
    Deserialize(#[source] reqwest::Error),
    #[error("Could not decode the given response")]
    Decode(#[source] ParseIntError),
    #[error("Could not find any searched item in response")]
    Missing,
}

pub struct ResolverClient {
    base_url: String,
    client: reqwest_middleware::ClientWithMiddleware,
}

impl ResolverClient {
    pub fn new(url: String, timeout: Duration) -> Result<Self, reqwest::Error> {
        Ok(Self {
            base_url: format!("{url}/v1/resolvers"),
            client: get_retryable_http_client(timeout)?,
        })
    }

    async fn resolve_multiple<S: Selector, O: DeserializeOwned, Q: Serialize>(
        &self,
        resource: &str,
        selector: S,
        query: Option<Q>,
    ) -> Result<ByChainTypeAndId<O>, ResolveError> {
        if selector.is_empty() {
            return Ok(HashMap::new());
        }

        let mut endpoint = format!("{}/{}", self.base_url, resource);
        if let Some(query) = query {
            endpoint.push('?');
            endpoint.push_str(&serde_qs::to_string(&query).map_err(ResolveError::SerializeQuery)?);
        }

        self.client
            .post(endpoint)
            .json(&selector)
            .send()
            .await
            .map_err(ResolveError::Network)?
            .json()
            .await
            .map_err(ResolveError::Deserialize)
    }

    async fn resolve_single<I: Serialize + Debug + Clone, O: DeserializeOwned, Q: Serialize>(
        &self,
        resource: &str,
        chain_type: ChainType,
        chain_id: i32,
        selector: I,
        query: Option<Q>,
    ) -> Result<O, ResolveError> {
        let mut filter: ByChainTypeAndId<I> = HashMap::new();
        filter
            .entry(chain_type)
            .or_default()
            .insert(chain_id, selector);
        self.resolve_multiple(resource, filter, query)
            .await?
            .remove(&chain_type)
            .ok_or(ResolveError::Missing)?
            .remove(&chain_id)
            .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_unpriced_tokens(
        &self,
        token_addresses: ByChainTypeAndId<HashSet<Address>>,
    ) -> Result<ByChainTypeAndId<HashMap<Address, Token>>, ResolveError> {
        self.resolve_multiple("tokens", token_addresses, None::<()>)
            .await
    }

    pub async fn resolve_priced_tokens(
        &self,
        token_addresses: ByChainTypeAndId<HashSet<Address>>,
    ) -> Result<ByChainTypeAndId<HashMap<Address, PricedToken>>, ResolveError> {
        self.resolve_multiple(
            "tokens",
            token_addresses,
            Some(ResolveTokensQuery {
                with_usd_prices: Some(true),
            }),
        )
        .await
    }

    pub async fn resolve_unpriced_token(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        token_address: Address,
    ) -> Result<Token, ResolveError> {
        self.resolve_single::<_, HashMap<Address, Token>, _>(
            "tokens",
            chain_type,
            chain_id,
            vec![token_address],
            None::<()>,
        )
        .await?
        .remove(&token_address)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_priced_token(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        token_address: Address,
    ) -> Result<PricedToken, ResolveError> {
        self.resolve_single::<_, HashMap<Address, PricedToken>, _>(
            "tokens",
            chain_type,
            chain_id,
            vec![token_address],
            Some(ResolveTokensQuery {
                with_usd_prices: Some(true),
            }),
        )
        .await?
        .remove(&token_address)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_amm_pools_without_tvl(
        &self,
        pool_ids: ByChainTypeAndId<HashSet<AmmPoolId>>,
    ) -> Result<ByChainTypeAndId<HashMap<AmmPoolId, AmmPool>>, ResolveError> {
        self.resolve_multiple("amms/pools", pool_ids, None::<()>)
            .await
    }

    pub async fn resolve_amm_pools_with_tvl(
        &self,
        pool_ids: ByChainTypeAndId<HashSet<AmmPoolId>>,
    ) -> Result<ByChainTypeAndId<HashMap<AmmPoolId, AmmPoolWithTvl>>, ResolveError> {
        self.resolve_multiple(
            "amms/pools",
            pool_ids,
            Some(ResolveAmmPoolsQuery {
                with_usd_tvls: Some(true),
                with_liquidity: Some(false),
            }),
        )
        .await
    }

    pub async fn resolve_amm_pools_with_tvl_and_liquidity(
        &self,
        pool_ids: ByChainTypeAndId<HashSet<AmmPoolId>>,
    ) -> Result<ByChainTypeAndId<HashMap<AmmPoolId, AmmPoolWithTvlAndLiquidity>>, ResolveError>
    {
        self.resolve_multiple(
            "amms/pools",
            pool_ids,
            Some(ResolveAmmPoolsQuery {
                with_usd_tvls: Some(true),
                with_liquidity: Some(true),
            }),
        )
        .await
    }

    pub async fn resolve_amm_pool_without_tvl(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        pool_id: AmmPoolId,
    ) -> Result<AmmPool, ResolveError> {
        self.resolve_single::<_, HashMap<AmmPoolId, AmmPool>, ()>(
            "amms/pools",
            chain_type,
            chain_id,
            vec![pool_id],
            None,
        )
        .await?
        .remove(&pool_id)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_amm_pool_with_tvl(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        pool_id: AmmPoolId,
    ) -> Result<AmmPoolWithTvl, ResolveError> {
        self.resolve_single::<_, HashMap<AmmPoolId, AmmPoolWithTvl>, ResolveAmmPoolsQuery>(
            "amms/pools",
            chain_type,
            chain_id,
            vec![pool_id],
            Some(ResolveAmmPoolsQuery {
                with_usd_tvls: Some(true),
                with_liquidity: None,
            }),
        )
        .await?
        .remove(&pool_id)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_amm_pool_with_tvl_and_liquidity(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        pool_id: AmmPoolId,
    ) -> Result<AmmPoolWithTvlAndLiquidity, ResolveError> {
        self.resolve_single::<_, HashMap<AmmPoolId, AmmPoolWithTvlAndLiquidity>, ResolveAmmPoolsQuery>(
            "amms/pools",
            chain_type,
            chain_id,
            vec![pool_id],
            Some(ResolveAmmPoolsQuery {
                with_usd_tvls: Some(true),
                with_liquidity: Some(true),
            }),
        )
        .await?
        .remove(&pool_id)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_prices(
        &self,
        token_addresses: ByChainTypeAndId<HashSet<Address>>,
    ) -> Result<ByChainTypeAndId<HashMap<Address, f64>>, ResolveError> {
        self.resolve_multiple("prices", token_addresses, None::<()>)
            .await
    }

    pub async fn resolve_price(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        token_address: Address,
    ) -> Result<f64, ResolveError> {
        self.resolve_single::<_, HashMap<Address, f64>, ()>(
            "prices",
            chain_type,
            chain_id,
            vec![token_address],
            None,
        )
        .await?
        .remove(&token_address)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_amm_pool_tvls(
        &self,
        pool_ids: ByChainTypeAndId<HashSet<AmmPoolId>>,
    ) -> Result<ByChainTypeAndId<HashMap<AmmPoolId, f64>>, ResolveError> {
        self.resolve_multiple("amms/tvls", pool_ids, None::<()>)
            .await
    }

    pub async fn resolve_amm_pool_tvl(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        pool_id: AmmPoolId,
    ) -> Result<f64, ResolveError> {
        self.resolve_single::<_, HashMap<AmmPoolId, f64>, ()>(
            "amms/tvls",
            chain_type,
            chain_id,
            vec![pool_id],
            None,
        )
        .await?
        .remove(&pool_id)
        .ok_or(ResolveError::Missing)
    }

    pub async fn get_amm_pools_with_usd_tvl_and_liquidity(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        dex: String,
    ) -> Result<HashMap<AmmPoolId, AmmPoolWithTvlAndLiquidity>, ResolveError> {
        self.client
            .get(format!(
                "{}/amms/pools-with-usd-tvls/{}/{}/{}",
                self.base_url, chain_type, chain_id, dex
            ))
            .send()
            .await
            .map_err(ResolveError::Network)?
            .json::<HashMap<AmmPoolId, AmmPoolWithTvlAndLiquidity>>()
            .await
            .map_err(ResolveError::Deserialize)
    }

    pub async fn resolve_amm_pool_liquidities_by_addresses(
        &self,
        addresses_by_pool_id: ByChainTypeAndId<HashMap<AmmPoolId, HashSet<Address>>>,
    ) -> Result<ByChainTypeAndId<HashMap<AmmPoolId, HashMap<Address, U256>>>, ResolveError> {
        self.resolve_multiple(
            "amms/liquidities-by-addresses",
            addresses_by_pool_id,
            None::<()>,
        )
        .await
    }

    pub async fn resolve_amm_pool_liquidity_by_addresses(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        pool_id: AmmPoolId,
        addresses: HashSet<Address>,
    ) -> Result<HashMap<Address, U256>, ResolveError> {
        let mut selector = HashMap::new();
        selector.insert(pool_id, addresses);

        self.resolve_single::<_, HashMap<AmmPoolId, HashMap<Address, U256>>, ()>(
            "amms/liquidities-by-addresses",
            chain_type,
            chain_id,
            selector,
            None,
        )
        .await?
        .remove(&pool_id)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_all_liquity_v2_collaterals_in_chain(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brands: HashSet<String>,
    ) -> Result<HashMap<String, HashMap<Address, LiquityV2Collateral>>, ResolveError> {
        let mut selector: HashMap<String, HashSet<Address>> = HashMap::new();
        for brand in brands.into_iter() {
            selector.insert(brand, HashSet::new());
        }

        self.resolve_single::<_, HashMap<String, HashMap<Address, LiquityV2Collateral>>, ()>(
            "liquity-v2/collaterals",
            chain_type,
            chain_id,
            selector,
            None::<()>,
        )
        .await
    }

    pub async fn resolve_all_liquity_v2_collaterals_in_chain_for_brand(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brand: String,
    ) -> Result<HashMap<Address, LiquityV2Collateral>, ResolveError> {
        let mut selector: HashMap<String, HashSet<Address>> = HashMap::new();
        selector.insert(brand.clone(), HashSet::new());

        self.resolve_single::<_, HashMap<String, HashMap<Address, LiquityV2Collateral>>, ()>(
            "liquity-v2/collaterals",
            chain_type,
            chain_id,
            selector,
            None::<()>,
        )
        .await?
        .remove(&brand)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_liquity_v2_collaterals_in_chain_for_brand(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brand: String,
        collaterals: HashSet<Address>,
    ) -> Result<HashMap<Address, LiquityV2Collateral>, ResolveError> {
        let mut brands: HashMap<String, HashSet<Address>> = HashMap::new();
        brands.insert(brand.clone(), collaterals);

        self.resolve_single::<_, HashMap<String, HashMap<Address, LiquityV2Collateral>>, ()>(
            "liquity-v2/collaterals",
            chain_type,
            chain_id,
            brands,
            None::<()>,
        )
        .await?
        .remove(&brand)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_all_liquity_v2_collaterals(
        &self,
        brands: ByChainTypeAndId<HashSet<String>>,
    ) -> Result<
        ByChainTypeAndId<HashMap<String, HashMap<Address, LiquityV2Collateral>>>,
        ResolveError,
    > {
        let mut selector: ByChainTypeAndId<HashMap<String, HashSet<Address>>> = HashMap::new();
        for (chain_type, brands_by_chain_id) in brands.into_iter() {
            for (chain_id, brands) in brands_by_chain_id.into_iter() {
                for brand in brands.into_iter() {
                    selector
                        .entry(chain_type)
                        .or_default()
                        .entry(chain_id)
                        .or_default()
                        .insert(brand, HashSet::new());
                }
            }
        }

        self.resolve_multiple("liquity-v2/collaterals", selector, None::<()>)
            .await
    }

    pub async fn resolve_liquity_v2_collaterals(
        &self,
        brands_by_chain: ByChainTypeAndId<HashMap<String, HashSet<Address>>>,
    ) -> Result<
        ByChainTypeAndId<HashMap<String, HashMap<Address, LiquityV2Collateral>>>,
        ResolveError,
    > {
        let mut selector: ByChainTypeAndId<HashMap<String, HashSet<Address>>> = HashMap::new();
        for (chain_type, brands_by_chain_id) in brands_by_chain.into_iter() {
            for (chain_id, brands) in brands_by_chain_id.into_iter() {
                for (brand, collaterals) in brands.into_iter() {
                    selector
                        .entry(chain_type)
                        .or_default()
                        .entry(chain_id)
                        .or_default()
                        .insert(brand, collaterals);
                }
            }
        }

        self.resolve_multiple("liquity-v2/collaterals", selector, None::<()>)
            .await
    }

    pub async fn resolve_all_gmx_v1_collaterals_in_chain(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brands: HashSet<String>,
    ) -> Result<HashMap<String, HashMap<Address, GmxV1Collateral>>, ResolveError> {
        let mut selector: HashMap<String, HashSet<Address>> = HashMap::new();
        for brand in brands.into_iter() {
            selector.insert(brand, HashSet::new());
        }

        self.resolve_single::<_, HashMap<String, HashMap<Address, GmxV1Collateral>>, ()>(
            "gmx-v1/collaterals",
            chain_type,
            chain_id,
            selector,
            None::<()>,
        )
        .await
    }

    pub async fn resolve_all_gmx_v1_collaterals_in_chain_for_brand(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brand: String,
    ) -> Result<HashMap<Address, GmxV1Collateral>, ResolveError> {
        let mut selector: HashMap<String, HashSet<Address>> = HashMap::new();
        selector.insert(brand.clone(), HashSet::new());

        self.resolve_single::<_, HashMap<String, HashMap<Address, GmxV1Collateral>>, ()>(
            "gmx-v1/collaterals",
            chain_type,
            chain_id,
            selector,
            None::<()>,
        )
        .await?
        .remove(&brand)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_gmx_v1_collaterals_in_chain_for_brand(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        brand: String,
        collaterals: HashSet<Address>,
    ) -> Result<HashMap<Address, GmxV1Collateral>, ResolveError> {
        let mut brands: HashMap<String, HashSet<Address>> = HashMap::new();
        brands.insert(brand.clone(), collaterals);

        self.resolve_single::<_, HashMap<String, HashMap<Address, GmxV1Collateral>>, ()>(
            "gmx-v1/collaterals",
            chain_type,
            chain_id,
            brands,
            None::<()>,
        )
        .await?
        .remove(&brand)
        .ok_or(ResolveError::Missing)
    }

    pub async fn resolve_all_gmx_v1_collaterals(
        &self,
        brands: ByChainTypeAndId<HashSet<String>>,
    ) -> Result<ByChainTypeAndId<HashMap<String, HashMap<Address, GmxV1Collateral>>>, ResolveError>
    {
        let mut selector: ByChainTypeAndId<HashMap<String, HashSet<Address>>> = HashMap::new();
        for (chain_type, brands_by_chain_id) in brands.into_iter() {
            for (chain_id, brands) in brands_by_chain_id.into_iter() {
                for brand in brands.into_iter() {
                    selector
                        .entry(chain_type)
                        .or_default()
                        .entry(chain_id)
                        .or_default()
                        .insert(brand, HashSet::new());
                }
            }
        }

        self.resolve_multiple("gmx-v1/collaterals", selector, None::<()>)
            .await
    }

    pub async fn resolve_gmx_v1_collaterals(
        &self,
        brands: ByChainTypeAndId<HashMap<String, HashSet<Address>>>,
    ) -> Result<ByChainTypeAndId<HashMap<String, HashMap<Address, GmxV1Collateral>>>, ResolveError>
    {
        let mut selector: ByChainTypeAndId<HashMap<String, HashSet<Address>>> = HashMap::new();
        for (chain_type, brands_by_chain_id) in brands.into_iter() {
            for (chain_id, brands) in brands_by_chain_id.into_iter() {
                for (brand, collaterals) in brands.into_iter() {
                    selector
                        .entry(chain_type)
                        .or_default()
                        .entry(chain_id)
                        .or_default()
                        .insert(brand, collaterals);
                }
            }
        }

        self.resolve_multiple("gmx-v1/collaterals", selector, None::<()>)
            .await
    }

    pub async fn resolve_latest_safe_block(
        &self,
        chain_type: ChainType,
        chain_id: i32,
    ) -> Result<BlockNumberAndTimestamp, ResolveError> {
        self.client
            .get(format!(
                "{}/blocks/{}/{}/latest-safe",
                self.base_url, chain_type, chain_id
            ))
            .send()
            .await
            .map_err(ResolveError::Network)?
            .json::<BlockNumberAndTimestamp>()
            .await
            .map_err(ResolveError::Deserialize)
    }

    pub async fn resolve_block_at(
        &self,
        chain_type: ChainType,
        chain_id: i32,
        timestamp: NaiveDateTime,
    ) -> Result<BlockNumberAndTimestamp, ResolveError> {
        self.client
            .get(format!(
                "{}/blocks/{}/{}/{}",
                self.base_url,
                chain_type,
                chain_id,
                timestamp.and_utc().timestamp()
            ))
            .send()
            .await
            .map_err(ResolveError::Network)?
            .json::<BlockNumberAndTimestamp>()
            .await
            .map_err(ResolveError::Deserialize)
    }
}

#[cfg(test)]
mod test {
    use serde_json::json;
    use wiremock::{
        Mock, MockServer, ResponseTemplate,
        matchers::{body_json, method},
    };

    use super::*;

    #[tokio::test]
    async fn test_resolve_multiple_serde() {
        let mock_server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(body_json(json!({
                "evm": { "17000": ["0x0000000000000000000000000000000000000001"] }
            })))
            .respond_with(ResponseTemplate::new(200).set_body_json(json!(
                {
                    "evm": {
                        "17000": {
                            "0x0000000000000000000000000000000000000001": {
                                "decimals": 18,
                                "name": "Mocked",
                                "symbol": "MCKD"
                            }
                        }
                    }
                }
            )))
            .up_to_n_times(1)
            .mount(&mock_server)
            .await;

        let client = ResolverClient::new(mock_server.uri(), Duration::from_secs(5)).unwrap();
        let resolved_token = client
            .resolve_unpriced_token(
                ChainType::Evm,
                17000,
                "0x0000000000000000000000000000000000000001"
                    .parse::<Address>()
                    .unwrap(),
            )
            .await
            .unwrap();

        assert_eq!(resolved_token.decimals, 18);
        assert_eq!(resolved_token.name, "Mocked");
        assert_eq!(resolved_token.symbol, "MCKD");
    }
}