tycho_simulation/rfq/protocols/liquorice/

client.rs

use std::{
    collections::{HashMap, HashSet},
    str::FromStr,
    sync::{
        atomic::{AtomicBool, Ordering},
        Arc,
    },
    time::SystemTime,
};

use alloy::primitives::utils::keccak256;
use async_trait::async_trait;
use base64::{engine::general_purpose::STANDARD as BASE64_STANDARD, Engine};
use futures::stream::BoxStream;
use num_bigint::BigUint;
use reqwest::{Client, RequestBuilder, Response, StatusCode};
use tokio::time::{interval, timeout, Duration};
use tracing::{debug, error, info, warn};
use tycho_common::{
    models::{protocol::GetAmountOutParams, Chain},
    simulation::indicatively_priced::SignedQuote,
    Bytes,
};

use crate::{
    evm::protocol::u256_num::biguint_to_u256,
    rfq::{
        client::RFQClient,
        errors::RFQError,
        models::{ComponentLayout, QuoteRule, TimestampHeader},
        protocols::{
            component,
            liquorice::models::{
                LiquoricePriceLevelsResponse, LiquoriceQuoteRequest, LiquoriceQuoteResponse,
                LiquoriceTokenPairPrice,
            },
            maker_price_levels::{self, MakerLevelsWithTvl, MakerPriceLevels},
        },
    },
    tycho_client::feed::synchronizer::{ComponentWithState, StateSyncMessage},
    tycho_common::models::protocol::{ProtocolComponent, ProtocolComponentState},
};

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct LiquoriceClient {
    chain: Chain,
    price_levels_endpoint: String,
    quote_endpoint: String,
    // Tokens that we want prices for
    tokens: HashSet<Bytes>,
    // Min tvl value in the quote token.
    tvl: f64,
    // solver header for authentication
    #[serde(skip_serializing, default)]
    auth_solver: String,
    // key header for authentication
    #[serde(skip_serializing, default)]
    auth_key: String,
    quote_tokens: HashSet<Bytes>,
    poll_time: Duration,
    quote_timeout: Duration,
    quote_expiry_secs: u64,
    #[serde(default)]
    component_layout: ComponentLayout,
    /// How often one route may take quotes from Liquorice. Read only by the all-pairs layout.
    #[serde(default = "LiquoriceClient::default_quote_rule")]
    quote_rule: QuoteRule,
    /// Liquorice issues credentials under two schemes: newer accounts use
    /// `Authorization: Basic base64(solver:key)`, legacy accounts use the
    /// separate `solver` + `authorization` headers. We start with Basic and
    /// permanently fall back to the legacy scheme if it returns 401.
    #[serde(skip)]
    use_legacy_auth: Arc<AtomicBool>,
}

impl LiquoriceClient {
    pub const PROTOCOL_SYSTEM: &'static str = "rfq:liquorice";
    pub const DEFAULT_QUOTE_RULE: QuoteRule = QuoteRule::OncePerMaker;

    #[allow(clippy::too_many_arguments)]
    pub fn new(
        chain: Chain,
        tokens: HashSet<Bytes>,
        tvl: f64,
        quote_tokens: HashSet<Bytes>,
        auth_solver: String,
        auth_key: String,
        poll_time: Duration,
        quote_timeout: Duration,
        quote_expiry_secs: u64,
    ) -> Result<Self, RFQError> {
        Ok(Self {
            chain,
            price_levels_endpoint: "https://api.liquorice.tech/v1/solver/price-levels".to_string(),
            quote_endpoint: "https://api.liquorice.tech/v1/solver/rfq".to_string(),
            tokens,
            tvl,
            auth_solver,
            auth_key,
            quote_tokens,
            poll_time,
            quote_timeout,
            quote_expiry_secs,
            component_layout: ComponentLayout::PerPair,
            quote_rule: Self::DEFAULT_QUOTE_RULE,
            use_legacy_auth: Arc::new(AtomicBool::new(false)),
        })
    }

    fn default_quote_rule() -> QuoteRule {
        Self::DEFAULT_QUOTE_RULE
    }

    pub(crate) fn with_component_layout(mut self, component_layout: ComponentLayout) -> Self {
        self.component_layout = component_layout;
        self
    }

    pub(crate) fn with_quote_rule(mut self, quote_rule: QuoteRule) -> Self {
        self.quote_rule = quote_rule;
        self
    }

    /// The name the client's stream tags its messages with. The two layouts use different names,
    /// so one stream builder can carry a client of each.
    fn stream_name(&self) -> &'static str {
        match self.component_layout {
            ComponentLayout::PerPair => "liquorice",
            ComponentLayout::AllPairs => "liquorice_all_pairs",
        }
    }

    pub fn quote_rule(&self) -> QuoteRule {
        self.quote_rule
    }

    #[cfg(test)]
    pub(crate) fn with_quote_endpoint(mut self, quote_endpoint: String) -> Self {
        self.quote_endpoint = quote_endpoint;
        self
    }

    /// Build the `Authorization: Basic <base64(solver:token)>` header value
    /// required by the Liquorice REST API.
    fn basic_auth_header(&self) -> String {
        let credentials = format!("{}:{}", self.auth_solver, self.auth_key);
        format!("Basic {}", BASE64_STANDARD.encode(credentials.as_bytes()))
    }

    /// Applies whichever auth scheme is currently active to the request.
    fn apply_auth(&self, request: RequestBuilder) -> RequestBuilder {
        if self
            .use_legacy_auth
            .load(Ordering::Relaxed)
        {
            request
                .header("solver", &self.auth_solver)
                .header("authorization", &self.auth_key)
        } else {
            request.header("authorization", self.basic_auth_header())
        }
    }

    /// Sends a request, retrying once with the legacy auth scheme if the
    /// server rejects Basic auth. The working scheme is remembered for the
    /// lifetime of the client.
    async fn send_authed(
        &self,
        build: impl Fn() -> RequestBuilder,
    ) -> Result<Response, reqwest::Error> {
        let response = self.apply_auth(build()).send().await?;
        if response.status() == StatusCode::UNAUTHORIZED &&
            !self
                .use_legacy_auth
                .swap(true, Ordering::Relaxed)
        {
            warn!("Liquorice Basic auth rejected (401); retrying with legacy solver/authorization headers");
            return self.apply_auth(build()).send().await;
        }
        Ok(response)
    }

    fn normalize_tvl(
        &self,
        raw_tvl: f64,
        quote_token: Bytes,
        prices_by_mm: &HashMap<String, Vec<LiquoriceTokenPairPrice>>,
    ) -> Result<f64, RFQError> {
        if self.quote_tokens.contains(&quote_token) {
            return Ok(raw_tvl);
        }

        for approved_quote_token in &self.quote_tokens {
            for token_prices in prices_by_mm.values() {
                for token_price in token_prices {
                    if token_price.base_token == quote_token &&
                        token_price.quote_token == *approved_quote_token
                    {
                        if let Some(price) = token_price.get_price_for_amount(1.0) {
                            return Ok(raw_tvl * price);
                        }
                    }
                }
            }
        }

        Ok(0.0)
    }

    fn create_component_with_state(
        &self,
        component_id: String,
        tokens: Vec<Bytes>,
        prices_by_mm: &HashMap<String, LiquoriceTokenPairPrice>,
        tvl: f64,
    ) -> ComponentWithState {
        let protocol_component = ProtocolComponent {
            id: component_id.clone(),
            protocol_system: Self::PROTOCOL_SYSTEM.to_string(),
            protocol_type_name: "liquorice_pool".to_string(),
            chain: self.chain,
            tokens,
            contract_addresses: vec![],
            ..Default::default()
        };

        let mut attributes = HashMap::new();

        let prices_json = serde_json::to_string(&prices_by_mm).unwrap_or_default();
        attributes.insert("prices".to_string(), prices_json.as_bytes().to_vec().into());

        ComponentWithState {
            state: ProtocolComponentState::new(&component_id, attributes, HashMap::new()),
            component: protocol_component,
            component_tvl: Some(tvl),
            entrypoints: vec![],
        }
    }

    /// Every market maker's prices on a pair whose tokens the client requested and whose TVL
    /// clears the threshold, each with its normalized TVL.
    fn levels_above_tvl_threshold<'a>(
        &self,
        prices_by_mm: &'a HashMap<String, Vec<LiquoriceTokenPairPrice>>,
    ) -> Result<Vec<MakerLevelsWithTvl<'a, LiquoriceTokenPairPrice>>, RFQError> {
        let mut kept = Vec::new();
        for (mm_name, token_pair_prices) in prices_by_mm.iter() {
            for token_pair_price in token_pair_prices {
                let base_token = &token_pair_price.base_token;
                let quote_token = &token_pair_price.quote_token;

                if !self.tokens.contains(base_token) || !self.tokens.contains(quote_token) {
                    continue;
                }

                let normalized_tvl = self.normalize_tvl(
                    token_pair_price.calculate_tvl(),
                    token_pair_price.quote_token.clone(),
                    prices_by_mm,
                )?;

                if normalized_tvl < self.tvl {
                    info!(
                        "Filtering out MM {} for pair {}/{} due to low TVL: {:.2} < {:.2}",
                        mm_name,
                        hex::encode(base_token),
                        hex::encode(quote_token),
                        normalized_tvl,
                        self.tvl
                    );
                    continue;
                }
                kept.push(MakerLevelsWithTvl {
                    market_maker: mm_name,
                    levels: token_pair_price,
                    tvl: normalized_tvl,
                });
            }
        }
        Ok(kept)
    }

    /// One component per pair in `levels_above_tvl_threshold`, holding every market maker on the
    /// pair. The component's TVL is the largest maker's.
    fn pair_components(
        &self,
        prices_by_mm: &HashMap<String, Vec<LiquoriceTokenPairPrice>>,
    ) -> Result<HashMap<String, ComponentWithState>, RFQError> {
        struct PricesWithTvl {
            // MM name -> price levels for the token pair
            mm_prices: HashMap<String, LiquoriceTokenPairPrice>,
            // The highest TVL among MMs for this token pair, used as the component's TVL
            tvl: f64,
        }
        let mut pair_mm_prices: HashMap<(Bytes, Bytes), PricesWithTvl> = HashMap::new();
        for MakerLevelsWithTvl {
            market_maker: mm_name,
            levels: token_pair_price,
            tvl: normalized_tvl,
        } in self.levels_above_tvl_threshold(prices_by_mm)?
        {
            let entry = pair_mm_prices
                .entry((token_pair_price.base_token.clone(), token_pair_price.quote_token.clone()))
                .or_insert_with(|| PricesWithTvl {
                    mm_prices: HashMap::new(),
                    tvl: f64::NEG_INFINITY,
                });
            entry.tvl = entry.tvl.max(normalized_tvl);
            entry
                .mm_prices
                .insert(mm_name.to_string(), token_pair_price.clone());
        }

        let mut new_components = HashMap::new();
        for ((base_token, quote_token), PricesWithTvl { mm_prices, tvl }) in pair_mm_prices {
            let pair_str =
                format!("liquorice_{}/{}", hex::encode(&base_token), hex::encode(&quote_token));
            let component_id = format!("{}", keccak256(pair_str.as_bytes()));
            let component_with_state = self.create_component_with_state(
                component_id.clone(),
                vec![base_token, quote_token],
                &mm_prices,
                tvl,
            );
            new_components.insert(component_id, component_with_state);
        }
        Ok(new_components)
    }

    /// The all-pairs component for one poll: every maker's price levels in
    /// `levels_above_tvl_threshold`. `None` when there is none.
    fn all_pairs_component(
        &self,
        prices_by_mm: &HashMap<String, Vec<LiquoriceTokenPairPrice>>,
    ) -> Result<Option<ComponentWithState>, RFQError> {
        let mut price_levels = Vec::new();
        for MakerLevelsWithTvl { market_maker: mm_name, levels: token_pair_price, tvl } in
            self.levels_above_tvl_threshold(prices_by_mm)?
        {
            let maker_levels = MakerPriceLevels {
                market_maker: mm_name.to_string(),
                base_token: token_pair_price.base_token.clone(),
                quote_token: token_pair_price.quote_token.clone(),
                levels: token_pair_price.levels.clone(),
            };
            price_levels.push((maker_levels, tvl));
        }
        maker_price_levels::all_pairs_component(
            Self::PROTOCOL_SYSTEM,
            "liquorice_pool",
            self.chain,
            price_levels,
            self.quote_rule,
        )
    }

    /// The best valid level of the response, from `market_maker` alone when one is named.
    fn process_quote_response(
        quote_response: LiquoriceQuoteResponse,
        params: &GetAmountOutParams,
        market_maker: Option<&str>,
    ) -> Result<SignedQuote, RFQError> {
        if !quote_response.liquidity_available {
            debug!(quote_response = ?quote_response, "Liquorice quote response indicates no liquidity");
            return Err(RFQError::QuoteNotFound(format!(
                "Liquorice quote not found for {} {} ->{}",
                params.amount_in, params.token_in, params.token_out,
            )));
        }

        info!("Received Liquorice quote response with {} levels", quote_response.levels.len());

        // Find the valid level with the largest quote_token_amount
        let best_level = quote_response
            .levels
            .iter()
            .filter(|level| level.validate(params).is_ok())
            .filter(|level| market_maker.is_none_or(|maker| level.maker == maker))
            .filter_map(|level| {
                BigUint::from_str(&level.quote_token_amount)
                    .ok()
                    .map(|amount| (level, amount))
            })
            .max_by(|(_, a), (_, b)| a.cmp(b));

        let (quote_level, _) = best_level.ok_or_else(|| {
            RFQError::QuoteNotFound(format!(
                "No valid Liquorice quote levels for {} {} ->{}",
                params.amount_in, params.token_in, params.token_out,
            ))
        })?;

        let mut quote_attributes: HashMap<String, Bytes> = HashMap::new();

        // calldata (pre-encoded by Liquorice API)
        quote_attributes.insert(
            "calldata".to_string(),
            Bytes::from(
                hex::decode(
                    quote_level
                        .tx
                        .data
                        .trim_start_matches("0x"),
                )
                .map_err(|e| RFQError::ParsingError(format!("Failed to parse calldata: {e}")))?,
            ),
        );

        // base_token_amount as U256 (32 bytes big-endian)
        quote_attributes.insert(
            "base_token_amount".to_string(),
            Bytes::from(
                biguint_to_u256(&BigUint::from_str(&quote_level.base_token_amount).map_err(
                    |_| {
                        RFQError::ParsingError(format!(
                            "Failed to parse base token amount: {}",
                            quote_level.base_token_amount
                        ))
                    },
                )?)
                .to_be_bytes::<32>()
                .to_vec(),
            ),
        );

        // partial fill info (if present)
        if let Some(pf) = &quote_level.partial_fill {
            quote_attributes.insert(
                "partial_fill_offset".to_string(),
                Bytes::from(pf.offset.to_be_bytes().to_vec()),
            );
            quote_attributes.insert(
                "min_base_token_amount".to_string(),
                Bytes::from(
                    biguint_to_u256(&BigUint::from_str(&pf.min_base_token_amount).map_err(
                        |_| {
                            RFQError::ParsingError(format!(
                                "Failed to parse min_base_token_amount: {}",
                                pf.min_base_token_amount
                            ))
                        },
                    )?)
                    .to_be_bytes::<32>()
                    .to_vec(),
                ),
            );
        }

        Ok(SignedQuote {
            base_token: params.token_in.clone(),
            quote_token: params.token_out.clone(),
            amount_in: BigUint::from_str(&quote_level.base_token_amount).map_err(|_| {
                RFQError::ParsingError(format!(
                    "Failed to parse amount in string: {}",
                    quote_level.base_token_amount
                ))
            })?,
            amount_out: BigUint::from_str(&quote_level.quote_token_amount).map_err(|_| {
                RFQError::ParsingError(format!(
                    "Failed to parse amount out string: {}",
                    quote_level.quote_token_amount
                ))
            })?,
            quote_attributes,
        })
    }

    async fn fetch_price_levels(
        &self,
    ) -> Result<HashMap<String, Vec<LiquoriceTokenPairPrice>>, RFQError> {
        let query_params = vec![("chainId", self.chain.id().to_string())];

        let http_client = Client::new();
        let response = self
            .send_authed(|| {
                http_client
                    .get(&self.price_levels_endpoint)
                    .query(&query_params)
                    .header("accept", "application/json")
            })
            .await
            .map_err(|e| RFQError::ConnectionError(format!("Failed to fetch price levels: {e}")))?;

        if !response.status().is_success() {
            return Err(RFQError::ConnectionError(format!(
                "HTTP error {}: {}",
                response.status(),
                response
                    .text()
                    .await
                    .unwrap_or_default()
            )));
        }

        let price_response: LiquoricePriceLevelsResponse = response.json().await.map_err(|e| {
            RFQError::ParsingError(format!("Failed to parse price levels response: {e}"))
        })?;

        Ok(price_response.prices)
    }

    /// Requests a firm quote. With `market_maker`, takes that maker's level alone.
    pub(crate) async fn request_quote(
        &self,
        params: &GetAmountOutParams,
        market_maker: Option<&str>,
    ) -> Result<SignedQuote, RFQError> {
        let expiry = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .map_err(|_| RFQError::ParsingError("SystemTime before UNIX EPOCH!".into()))?
            .as_secs() +
            self.quote_expiry_secs;

        let rfq_id = uuid::Uuid::new_v4().to_string();

        let quote_request = LiquoriceQuoteRequest {
            chain_id: self.chain.id(),
            rfq_id: rfq_id.clone(),
            expiry,
            base_token: params.token_in.to_string(),
            quote_token: params.token_out.to_string(),
            trader: params.receiver.to_string(),
            effective_trader: Some(params.sender.to_string()),
            base_token_amount: Some(params.amount_in.to_string()),
            quote_token_amount: None,
        };

        debug!(quote_request = ?quote_request, "Sending Liquorice quote request");

        let url = self.quote_endpoint.clone();

        let start_time = std::time::Instant::now();
        const MAX_RETRIES: u32 = 3;
        let mut last_error = None;

        for attempt in 0..MAX_RETRIES {
            let elapsed = start_time.elapsed();
            if elapsed >= self.quote_timeout {
                return Err(last_error.unwrap_or_else(|| {
                    RFQError::ConnectionError(format!(
                        "Liquorice quote request timed out after {} seconds",
                        self.quote_timeout.as_secs()
                    ))
                }));
            }

            let remaining_time = self.quote_timeout - elapsed;

            let http_client = Client::new();
            let response = match timeout(
                remaining_time,
                self.send_authed(|| {
                    http_client
                        .post(&url)
                        .json(&quote_request)
                        .header("accept", "application/json")
                }),
            )
            .await
            {
                Ok(Ok(resp)) => resp,
                Ok(Err(e)) => {
                    warn!(
                        "Liquorice quote request failed (attempt {}/{}): {}",
                        attempt + 1,
                        MAX_RETRIES,
                        e
                    );
                    last_error = Some(RFQError::ConnectionError(format!(
                        "Failed to send Liquorice quote request: {e}"
                    )));
                    if attempt < MAX_RETRIES - 1 {
                        tokio::time::sleep(Duration::from_millis(100)).await;
                        continue;
                    } else {
                        return Err(last_error.unwrap());
                    }
                }
                Err(_) => {
                    return Err(RFQError::ConnectionError(format!(
                        "Liquorice quote request timed out after {} seconds",
                        self.quote_timeout.as_secs()
                    )));
                }
            };

            if response.status() != 200 {
                let err_msg = match response.text().await {
                    Ok(text) => text,
                    Err(e) => {
                        warn!(
                            "Liquorice error response parsing failed (attempt {}/{}): {}",
                            attempt + 1,
                            MAX_RETRIES,
                            e
                        );
                        last_error = Some(RFQError::ParsingError(format!(
                            "Failed to read response text from Liquorice failed request: {e}"
                        )));
                        if attempt < MAX_RETRIES - 1 {
                            tokio::time::sleep(Duration::from_millis(100)).await;
                            continue;
                        } else {
                            return Err(last_error.unwrap());
                        }
                    }
                };
                last_error = Some(RFQError::FatalError(format!(
                    "Failed to send Liquorice quote request: {err_msg}",
                )));
                if attempt < MAX_RETRIES - 1 {
                    warn!(
                        "Liquorice returned non-200 status (attempt {}/{}): {}",
                        attempt + 1,
                        MAX_RETRIES,
                        err_msg
                    );
                    tokio::time::sleep(Duration::from_millis(100)).await;
                    continue;
                } else {
                    return Err(last_error.unwrap());
                }
            }

            let quote_response = match response
                .json::<LiquoriceQuoteResponse>()
                .await
            {
                Ok(resp) => resp,
                Err(e) => {
                    warn!(
                        "Liquorice quote response parsing failed (attempt {}/{}): {}",
                        attempt + 1,
                        MAX_RETRIES,
                        e
                    );
                    last_error = Some(RFQError::ParsingError(format!(
                        "Failed to parse Liquorice quote response: {e}"
                    )));
                    if attempt < MAX_RETRIES - 1 {
                        tokio::time::sleep(Duration::from_millis(100)).await;
                        continue;
                    } else {
                        return Err(last_error.unwrap());
                    }
                }
            };

            return Self::process_quote_response(quote_response, params, market_maker);
        }

        Err(last_error.unwrap_or_else(|| {
            RFQError::ConnectionError("Liquorice quote request failed after retries".to_string())
        }))
    }
}

#[async_trait]
impl RFQClient for LiquoriceClient {
    fn stream(
        &self,
    ) -> BoxStream<'static, Result<(String, StateSyncMessage<TimestampHeader>), RFQError>> {
        let client = self.clone();

        Box::pin(async_stream::stream! {
            let mut current_components: HashMap<String, ComponentWithState> = HashMap::new();
            let mut ticker = interval(client.poll_time);

            info!("Starting Liquorice price levels polling every {} seconds", client.poll_time.as_secs());
            info!("TVL threshold: {:.2}", client.tvl);

            loop {
                ticker.tick().await;

                let prices_by_mm = match client.fetch_price_levels().await {
                    Ok(prices_by_mm) => prices_by_mm,
                    Err(e) => {
                        error!("Failed to fetch price levels from Liquorice API: {}", e);
                        continue;
                    }
                };
                info!("Fetched price levels from {} market makers", prices_by_mm.len());
                let components = match client.component_layout {
                    ComponentLayout::PerPair => client.pair_components(&prices_by_mm)?,
                    ComponentLayout::AllPairs => match client.all_pairs_component(&prices_by_mm) {
                        Ok(component) => component
                            .into_iter()
                            .map(|component| (component.component.id.clone(), component))
                            .collect(),
                        Err(e) => {
                            error!("Failed to build the Liquorice component: {}", e);
                            continue;
                        }
                    },
                };
                let timestamp = component::unix_timestamp()?;
                let msg = component::poll_message(&mut current_components, components, timestamp);
                yield Ok((client.stream_name().to_string(), msg));
            }
        })
    }

    async fn request_binding_quote(
        &self,
        params: &GetAmountOutParams,
    ) -> Result<SignedQuote, RFQError> {
        self.request_quote(params, None).await
    }
}

#[cfg(test)]
mod tests {
    use std::{str::FromStr, time::Duration};

    use super::*;
    use crate::rfq::{
        models::PriceLevel,
        protocols::{
            component::{BOOKS_ATTRIBUTE, SWAP_DIRECTIONS_ATTRIBUTE},
            liquorice::models::{
                LiquoricePartialFill, LiquoriceQuoteLevel, LiquoriceQuoteResponse,
                LiquoriceTokenPairPrice, LiquoriceTx,
            },
            maker_price_levels::MakerPriceLevels,
            test_utils::{mock_quote_server, quote_params, LIQUORICE_QUOTE_RESPONSE},
        },
    };

    #[test]
    fn test_normalize_tvl_same_quote_token() {
        let client = create_test_client();
        let prices = HashMap::new();

        let result = client.normalize_tvl(
            1000.0,
            Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap(),
            &prices,
        );
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), 1000.0);
    }

    #[test]
    fn test_normalize_tvl_different_quote_token() {
        let client = create_test_client();
        let mut prices = HashMap::new();
        let weth = Bytes::from_str("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap();
        let usdc = Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap();

        let eth_usdc_price = LiquoriceTokenPairPrice {
            base_token: weth.clone(),
            quote_token: usdc,
            levels: vec![PriceLevel { quantity: 1.0, price: 3000.0 }],
            updated_at: None,
        };

        prices.insert("test_mm".to_string(), vec![eth_usdc_price]);

        let result = client.normalize_tvl(2.0, weth, &prices);
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), 6000.0);
    }

    #[test]
    fn test_normalize_tvl_no_conversion_available() {
        let client = create_test_client();
        let prices = HashMap::new();
        let result = client.normalize_tvl(
            1000.0,
            Bytes::from_str("0x1234567890123456789012345678901234567890").unwrap(),
            &prices,
        );
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), 0.0);
    }

    fn create_test_client() -> LiquoriceClient {
        let quote_tokens = HashSet::from([
            Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap(), // USDC
            Bytes::from_str("0xdAC17F958D2ee523a2206206994597C13D831ec7").unwrap(), // USDT
        ]);

        LiquoriceClient::new(
            Chain::Ethereum,
            HashSet::new(),
            1.0,
            quote_tokens,
            "test_solver".to_string(),
            "test_key".to_string(),
            Duration::from_secs(5),
            Duration::from_secs(5),
            300,
        )
        .unwrap()
    }

    fn create_test_liquorice_client(
        quote_endpoint: String,
        quote_timeout: Duration,
    ) -> LiquoriceClient {
        let token_in = Bytes::from_str("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap();
        let token_out = Bytes::from_str("0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599").unwrap();

        LiquoriceClient {
            chain: Chain::Ethereum,
            price_levels_endpoint: "http://unused/price-levels".to_string(),
            quote_endpoint,
            tokens: HashSet::from([token_in, token_out]),
            tvl: 10.0,
            auth_solver: "test_solver".to_string(),
            auth_key: "test_key".to_string(),
            quote_tokens: HashSet::new(),
            poll_time: Duration::from_secs(0),
            quote_timeout,
            quote_expiry_secs: 300,
            component_layout: ComponentLayout::PerPair,
            quote_rule: QuoteRule::OncePerMaker,
            use_legacy_auth: Arc::new(AtomicBool::new(false)),
        }
    }

    fn make_quote_level(
        base_token: &str,
        quote_token: &str,
        base_token_amount: &str,
        quote_token_amount: &str,
        partial_fill: Option<LiquoricePartialFill>,
    ) -> LiquoriceQuoteLevel {
        LiquoriceQuoteLevel {
            maker_rfq_id: "maker-1".to_string(),
            maker: "test-maker".to_string(),
            expiry: 9999999999,
            tx: LiquoriceTx {
                to: "0x1111111111111111111111111111111111111111".to_string(),
                data: "0xdeadbeef".to_string(),
            },
            base_token: base_token.to_string(),
            quote_token: quote_token.to_string(),
            base_token_amount: base_token_amount.to_string(),
            quote_token_amount: quote_token_amount.to_string(),
            partial_fill,
        }
    }

    fn make_params(token_in: &str, token_out: &str, amount_in: u64) -> GetAmountOutParams {
        GetAmountOutParams {
            amount_in: BigUint::from(amount_in),
            token_in: Bytes::from_str(token_in).unwrap(),
            token_out: Bytes::from_str(token_out).unwrap(),
            sender: Bytes::from_str("0x3333333333333333333333333333333333333333").unwrap(),
            receiver: Bytes::from_str("0x4444444444444444444444444444444444444444").unwrap(),
            origin: None,
        }
    }

    #[test]
    fn test_process_quote_response_no_liquidity() {
        let response = LiquoriceQuoteResponse {
            rfq_id: "r1".to_string(),
            liquidity_available: false,
            levels: vec![],
        };
        let params = make_params(
            "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
            "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
            1_000_000_000_000_000_000,
        );
        let result = LiquoriceClient::process_quote_response(response, &params, None);
        assert!(
            matches!(result, Err(RFQError::QuoteNotFound(_))),
            "expected QuoteNotFound, got {:?}",
            result
        );
    }

    #[test]
    fn test_process_quote_response_partial_fill_attributes() {
        let token_in = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
        let token_out = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
        let amount_in = 1_000_000_000_000_000_000u64;

        let level = make_quote_level(
            token_in,
            token_out,
            &amount_in.to_string(),
            "3329502",
            Some(LiquoricePartialFill {
                offset: 68,
                min_base_token_amount: "500000000000000000".to_string(),
            }),
        );
        let response = LiquoriceQuoteResponse {
            rfq_id: "r1".to_string(),
            liquidity_available: true,
            levels: vec![level],
        };
        let params = make_params(token_in, token_out, amount_in);

        let quote = LiquoriceClient::process_quote_response(response, &params, None).unwrap();

        // partial_fill_offset: 4-byte big-endian encoding of 68
        let offset_bytes = quote.quote_attributes["partial_fill_offset"].clone();
        assert_eq!(offset_bytes.as_ref(), &68u32.to_be_bytes());

        // min_base_token_amount: 32-byte big-endian U256 of 500000000000000000
        let min_amount_bytes = quote.quote_attributes["min_base_token_amount"].clone();
        assert_eq!(min_amount_bytes.len(), 32);
        let expected_min = BigUint::from(500_000_000_000_000_000u64);
        let actual_min = BigUint::from_bytes_be(min_amount_bytes.as_ref());
        assert_eq!(actual_min, expected_min);
    }

    #[test]
    fn test_process_quote_response_selects_best_valid_level() {
        let token_in = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
        let token_out = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
        let amount_in = 1_000_000_000_000_000_000u64;

        // One level with wrong base_token_amount (will fail validate) and two
        // valid levels with different quote_token_amounts; expect the higher one
        // to be chosen.
        let invalid_level = make_quote_level(token_in, token_out, "999", "9999999", None);
        let lower_level =
            make_quote_level(token_in, token_out, &amount_in.to_string(), "3000000", None);
        let best_level =
            make_quote_level(token_in, token_out, &amount_in.to_string(), "3500000", None);

        let response = LiquoriceQuoteResponse {
            rfq_id: "r1".to_string(),
            liquidity_available: true,
            levels: vec![invalid_level, lower_level, best_level],
        };
        let params = make_params(token_in, token_out, amount_in);

        let quote = LiquoriceClient::process_quote_response(response, &params, None).unwrap();
        assert_eq!(quote.amount_out, BigUint::from(3_500_000u64));
    }

    /// A level from `test-maker` paying 3000000 and one from `other-maker` paying 3500000.
    fn two_maker_response() -> (LiquoriceQuoteResponse, GetAmountOutParams) {
        let token_in = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
        let token_out = "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
        let amount_in = 1_000_000_000_000_000_000u64;
        let mut other_maker =
            make_quote_level(token_in, token_out, &amount_in.to_string(), "3500000", None);
        other_maker.maker = "other-maker".to_string();
        let named_maker =
            make_quote_level(token_in, token_out, &amount_in.to_string(), "3000000", None);
        let response = LiquoriceQuoteResponse {
            rfq_id: "r1".to_string(),
            liquidity_available: true,
            levels: vec![other_maker, named_maker],
        };
        (response, make_params(token_in, token_out, amount_in))
    }

    #[test]
    fn test_process_quote_response_named_maker() {
        let (response, params) = two_maker_response();
        let quote =
            LiquoriceClient::process_quote_response(response, &params, Some("test-maker")).unwrap();
        assert_eq!(quote.amount_out, BigUint::from(3_000_000u64), "the named maker's level wins");
    }

    #[test]
    fn test_process_quote_response_named_maker_absent() {
        let (response, params) = two_maker_response();
        let missing = LiquoriceClient::process_quote_response(response, &params, Some("absent"));
        assert!(matches!(missing, Err(RFQError::QuoteNotFound(_))));
    }

    fn levels(base: &Bytes, quote: &Bytes, levels: &[(f64, f64)]) -> LiquoriceTokenPairPrice {
        LiquoriceTokenPairPrice {
            base_token: base.clone(),
            quote_token: quote.clone(),
            levels: levels
                .iter()
                .map(|&(quantity, price)| PriceLevel { quantity, price })
                .collect(),
            updated_at: None,
        }
    }

    #[test]
    fn test_all_pairs_component_keeps_books_above_tvl_threshold() {
        let weth = Bytes::from_str("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap();
        let wbtc = Bytes::from_str("0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599").unwrap();
        let usdc = Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap();
        let mut client =
            create_test_liquorice_client("http://unused/rfq".to_string(), Duration::from_secs(1));
        client.tokens = HashSet::from([weth.clone(), wbtc.clone(), usdc.clone()]);
        client.quote_tokens = HashSet::from([usdc.clone()]);
        client.tvl = 100.0;
        let prices_by_mm = HashMap::from([
            (
                "mm_b".to_string(),
                vec![
                    levels(&weth, &usdc, &[(1.0, 3000.0)]),
                    levels(&wbtc, &usdc, &[(0.001, 65.0)]),
                ],
            ),
            ("mm_a".to_string(), vec![levels(&weth, &usdc, &[(2.0, 3000.0)])]),
        ]);

        let component = client
            .all_pairs_component(&prices_by_mm)
            .unwrap()
            .expect("two makers' price levels clear the threshold");

        assert_eq!(
            component.component.id,
            component::component_id(LiquoriceClient::PROTOCOL_SYSTEM, client.chain)
        );
        assert_eq!(
            component.component_tvl,
            Some(9000.0),
            "the WBTC price levels are below the threshold"
        );
        let mut expected_tokens = vec![weth.clone(), usdc.clone()];
        expected_tokens.sort();
        assert_eq!(component.component.tokens, expected_tokens);
        let mut expected_directions = weth.to_vec();
        expected_directions.extend_from_slice(&usdc);
        assert_eq!(
            component.component.static_attributes[SWAP_DIRECTIONS_ATTRIBUTE].to_vec(),
            expected_directions
        );
        assert_eq!(
            component.component.static_attributes[QuoteRule::ATTRIBUTE].as_ref(),
            b"once_per_maker"
        );
        let price_levels: Vec<MakerPriceLevels> =
            serde_json::from_slice(&component.state.attributes[BOOKS_ATTRIBUTE]).unwrap();
        assert_eq!(price_levels.len(), 2);
        assert_eq!(price_levels[0].market_maker, "mm_a", "price levels are sorted by maker");
        assert_eq!(price_levels[0].levels[0].quantity, 2.0);
        assert_eq!(price_levels[1].market_maker, "mm_b");
    }

    /// Each component carries the id and attributes the per-pair state decodes.
    #[test]
    fn test_pair_components_keep_pairs_above_tvl_threshold() {
        let weth = Bytes::from_str("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2").unwrap();
        let usdc = Bytes::from_str("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").unwrap();
        let mut client =
            create_test_liquorice_client("http://unused/rfq".to_string(), Duration::from_secs(1));
        client.tokens = HashSet::from([weth.clone(), usdc.clone()]);
        client.quote_tokens = HashSet::from([usdc.clone()]);
        client.tvl = 100.0;
        let prices_by_mm = HashMap::from([
            ("mm_a".to_string(), vec![levels(&weth, &usdc, &[(2.0, 3000.0)])]),
            ("mm_b".to_string(), vec![levels(&weth, &usdc, &[(1.0, 3000.0)])]),
        ]);

        let components = client
            .pair_components(&prices_by_mm)
            .unwrap();

        let pair_str = format!("liquorice_{}/{}", hex::encode(&weth), hex::encode(&usdc));
        let component = &components[&keccak256(pair_str.as_bytes()).to_string()];
        assert_eq!(components.len(), 1);
        assert_eq!(component.component.tokens, vec![weth, usdc]);
        assert_eq!(component.component_tvl, Some(6000.0), "the largest maker's TVL");
        let prices: HashMap<String, LiquoriceTokenPairPrice> =
            serde_json::from_slice(&component.state.attributes["prices"]).unwrap();
        assert_eq!(prices.len(), 2);
    }

    #[tokio::test]
    async fn test_liquorice_quote_timeout() {
        let (addr, _) = mock_quote_server(500, LIQUORICE_QUOTE_RESPONSE).await;

        let client_short_timeout = create_test_liquorice_client(
            format!("http://127.0.0.1:{}/rfq", addr.port()),
            Duration::from_millis(200),
        );
        let params = quote_params();

        let start = std::time::Instant::now();
        let result = client_short_timeout
            .request_binding_quote(&params)
            .await;
        let elapsed = start.elapsed();

        assert!(result.is_err());
        let err = result.unwrap_err();
        match err {
            RFQError::ConnectionError(msg) => {
                assert!(msg.contains("timed out"), "Expected timeout error, got: {}", msg);
            }
            _ => panic!("Expected ConnectionError, got: {:?}", err),
        }
        assert!(
            elapsed.as_millis() >= 200 && elapsed.as_millis() < 400,
            "Expected timeout around 200ms, got: {:?}",
            elapsed
        );

        let client_long_timeout = create_test_liquorice_client(
            format!("http://127.0.0.1:{}/rfq", addr.port()),
            Duration::from_secs(1),
        );

        let result = client_long_timeout
            .request_binding_quote(&params)
            .await;
        assert!(result.is_ok(), "Expected success, got: {:?}", result);
    }

    async fn create_retry_server() -> (std::net::SocketAddr, std::sync::Arc<std::sync::Mutex<u32>>)
    {
        use std::sync::{Arc, Mutex};

        use tokio::{io::AsyncWriteExt, net::TcpListener};

        let request_count = Arc::new(Mutex::new(0u32));
        let request_count_clone = request_count.clone();

        let listener = TcpListener::bind("127.0.0.1:0")
            .await
            .unwrap();
        let addr = listener.local_addr().unwrap();

        let json_response = r#"{"rfqId":"test-rfq-id","liquidityAvailable":true,"levels":[{"makerRfqId":"maker-rfq-1","maker":"test-maker","nonce":"0x0000000000000000000000000000000000000000000000000000000000000001","expiry":1707847360,"tx":{"to":"0x71D9750ECF0c5081FAE4E3EDC4253E52024b0B59","data":"0xdeadbeef"},"baseToken":"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2","quoteToken":"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599","baseTokenAmount":"1000000000000000000","quoteTokenAmount":"3329502","partialFill":null,"allowances":[]}]}"#;

        tokio::spawn(async move {
            while let Ok((mut stream, _)) = listener.accept().await {
                let count_clone = request_count_clone.clone();
                let json_response_clone = json_response.to_owned();
                tokio::spawn(async move {
                    *count_clone.lock().unwrap() += 1;
                    let count = *count_clone.lock().unwrap();
                    println!("Mock server: Received request #{count}");

                    if count <= 2 {
                        let response = "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 21\r\n\r\nInternal Server Error";
                        let _ = stream
                            .write_all(response.as_bytes())
                            .await;
                    } else {
                        let response = format!(
                            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
                            json_response_clone.len(),
                            json_response_clone
                        );
                        let _ = stream
                            .write_all(response.as_bytes())
                            .await;
                    }
                    let _ = stream.flush().await;
                    let _ = stream.shutdown().await;
                });
            }
        });

        tokio::time::sleep(Duration::from_millis(50)).await;
        (addr, request_count)
    }

    #[tokio::test]
    async fn test_liquorice_quote_retry_on_bad_response() {
        let (addr, request_count) = create_retry_server().await;

        let client = create_test_liquorice_client(
            format!("http://127.0.0.1:{}/rfq", addr.port()),
            Duration::from_secs(5),
        );
        let params = quote_params();
        let result = client
            .request_binding_quote(&params)
            .await;

        assert!(result.is_ok(), "Expected success after retries, got: {:?}", result);
        let quote = result.unwrap();

        assert_eq!(quote.amount_in, BigUint::from(1_000000000000000000u64));
        assert_eq!(quote.amount_out, BigUint::from(3329502u64));

        let final_count = *request_count.lock().unwrap();
        assert_eq!(final_count, 3, "Expected 3 requests, got {}", final_count);
    }
}