Problem loading certain uniswap_v4 pools

[johnwhitton]

When using get_amount for certain uniswap_v4 pools it errors

Note: although the example below is from unichain, this also occurs on base and ethereum.

For now I'm just ignoring these pools.

Here is an example using quickstart

lib/tycho-simulation $ cargo run --example quickstart -- --sell-token 0x0000000000000000000000000000000000000000 --buy-token 0x0555e30da8f98308edb960aa94c0db47230d2b9c --chain unichain
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.72s
     Running `target/debug/examples/quickstart --sell-token 0x0000000000000000000000000000000000000000 --buy-token 0x0555e30da8f98308edb960aa94c0db47230d2b9c --chain unichain`
Loading tokens from Tycho... tycho-unichain-beta.propellerheads.xyz
Tokens loaded: 117723

thread 'main' panicked at examples/quickstart/main.rs:152:10:
Buy token not found
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
lib/tycho-simulation $ pwd
/Users/johnwhitton/dev/jincubator/solver/lib/tycho-simulation
lib/tycho-simulation $ cargo run --example quickstart -- --sell-token 0x0000000000000000000000000000000000000000 --buy-token 0x0555e30da8f98308edb960aa94c0db47230d2b9c --chain unichain
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.50s
     Running `target/debug/examples/quickstart --sell-token 0x0000000000000000000000000000000000000000 --buy-token 0x0555e30da8f98308edb960aa94c0db47230d2b9c --chain unichain`
Loading tokens from Tycho... tycho-unichain-beta.propellerheads.xyz
Tokens loaded: 117707

thread 'main' panicked at examples/quickstart/main.rs:152:10:
Buy token not found
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
lib/tycho-simulation $

And here is a log from my implementation

🚨 CRITICAL ERROR: Overflow panic in get_amount_out!
🚨 Problematic Pool ID: 0x410723c1949069324d0f6013dba28829c4a0562f7c81d0f7cb79ded668691e1f
🚨 Pool Protocol: uniswap_v4
🚨 From Token: ETH (0x0000000000000000000000000000000000000000)
🚨 To Token: UNKNOWN (0x0555e30da8f98308edb960aa94c0db47230d2b9c)
🚨 Input Amount: ETH 1 (1000000000000000000 wei)
🚨 Panic Info: Any { .. }
🚨 Exiting due to overflow error in pool 0x410723c1949069324d0f6013dba28829c4a0562f7c81d0f7cb79ded668691e1f

[johnwhitton]

Note: avoiding u64 wherever possible and implementing better math, like below or crates like ethnum or rust_decimal, may help

// math.rs
use num_bigint::BigUint;
use num_traits::ToPrimitive;
use serde::de::{self, Unexpected, Visitor};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt;
use std::ops::{Add, Div, Mul, Sub};
use std::str::FromStr;

/// Fixed-point decimal with 18 decimals (like Ethereum wei)
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct FixedPoint(pub u128);

impl FixedPoint {
    pub const DECIMALS: u128 = 1_000_000_000_000_000_000; // 1e18
    pub const DECIMAL_PLACES: usize = 18;

    pub fn from_scaled(raw: u128) -> Self {
        FixedPoint(raw)
    }
    pub fn as_scaled(&self) -> u128 {
        self.0
    }

    /// Convert from wei amount with specified decimals to FixedPoint
    pub fn from_wei(amount: u128, decimals: u8) -> Self {
        if decimals == 18 {
            FixedPoint(amount)
        } else if decimals < 18 {
            // Scale up: multiply by 10^(18 - decimals)
            let scale_factor = 10u128.pow((18 - decimals) as u32);
            FixedPoint(amount * scale_factor)
        } else {
            // Scale down: divide by 10^(decimals - 18)
            let scale_factor = 10u128.pow((decimals - 18) as u32);
            FixedPoint(amount / scale_factor)
        }
    }

    /// Convert to wei amount with specified decimals
    pub fn to_wei(&self, decimals: u8) -> u128 {
        if decimals == 18 {
            self.0
        } else if decimals < 18 {
            // Scale down: divide by 10^(18 - decimals)
            let scale_factor = 10u128.pow((18 - decimals) as u32);
            self.0 / scale_factor
        } else {
            // Scale up: multiply by 10^(decimals - 18)
            let scale_factor = 10u128.pow((decimals - 18) as u32);
            self.0 * scale_factor
        }
    }

    /// Convert from f64 amount with specified decimals to FixedPoint
    pub fn from_f64_with_decimals(value: f64, decimals: u8) -> Self {
        let scale_factor = 10u128.pow(decimals as u32);
        FixedPoint((value * (scale_factor as f64)).round() as u128)
    }

    /// Convert from BigUint with specified decimals to FixedPoint
    pub fn from_bigint(bigint: &BigUint, decimals: u8) -> Self {
        // Convert BigUint to u128, handling overflow
        let amount = if bigint.bits() <= 128 {
            bigint.to_u128().unwrap_or(0)
        } else {
            // If BigUint is too large, truncate to u128::MAX
            u128::MAX
        };
        Self::from_wei(amount, decimals)
    }

    /// Convert to BigUint with specified decimals
    pub fn to_bigint(&self, decimals: u8) -> BigUint {
        BigUint::from(self.to_wei(decimals))
    }

    pub fn to_f64(&self) -> f64 {
        (self.0 as f64) / (Self::DECIMALS as f64)
    }
    pub fn from_f64(value: f64) -> Self {
        FixedPoint((value * (Self::DECIMALS as f64)).round() as u128)
    }

    pub fn to_decimal_string(&self) -> String {
        let int_part = self.0 / Self::DECIMALS;
        let frac_part = self.0 % Self::DECIMALS;
        if frac_part == 0 {
            return int_part.to_string();
        }
        let mut frac_str = format!("{:018}", frac_part);
        while frac_str.ends_with('0') {
            frac_str.pop();
        }
        format!("{}.{}", int_part, frac_str)
    }

    pub fn from_str_decimal(s: &str) -> Result<Self, String> {
        let parts: Vec<&str> = s.split('.').collect();
        if parts.len() > 2 {
            return Err(format!("Invalid decimal string: {}", s));
        }
        let int_part: u128 = parts[0]
            .parse()
            .map_err(|_| format!("Invalid integer part: {}", parts[0]))?;
        let mut value = int_part
            .checked_mul(Self::DECIMALS)
            .ok_or("Overflow in integer scaling")?;
        if parts.len() == 2 {
            let frac_str = parts[1];
            if frac_str.len() > Self::DECIMAL_PLACES {
                return Err(format!(
                    "Too many decimal places (max {}): {}",
                    Self::DECIMAL_PLACES,
                    frac_str
                ));
            }
            let padded = format!("{:0<18}", frac_str);
            let frac_part: u128 = padded[0..18]
                .parse()
                .map_err(|_| format!("Invalid fractional part: {}", frac_str))?;
            value = value
                .checked_add(frac_part)
                .ok_or("Overflow in fractional scaling")?;
        }
        Ok(FixedPoint(value))
    }
}

impl fmt::Display for FixedPoint {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_decimal_string())
    }
}

impl FromStr for FixedPoint {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Self::from_str_decimal(s)
    }
}

impl Serialize for FixedPoint {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.to_decimal_string())
    }
}

impl<'de> Deserialize<'de> for FixedPoint {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct FixedPointVisitor;
        impl<'de> Visitor<'de> for FixedPointVisitor {
            type Value = FixedPoint;
            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
                f.write_str("a decimal string like \"0.01\" or a raw u128 integer")
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                FixedPoint::from_str_decimal(v).map_err(E::custom)
            }
            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                Ok(FixedPoint(v as u128))
            }
            fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                Ok(FixedPoint(v))
            }
            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                if v < 0 {
                    return Err(E::invalid_value(
                        Unexpected::Signed(v),
                        &"non-negative number",
                    ));
                }
                Ok(FixedPoint(v as u128))
            }
        }
        deserializer.deserialize_any(FixedPointVisitor)
    }
}

// Arithmetic
impl Add for FixedPoint {
    type Output = FixedPoint;
    fn add(self, rhs: FixedPoint) -> FixedPoint {
        FixedPoint(self.0.checked_add(rhs.0).unwrap_or(u128::MAX))
    }
}
impl Sub for FixedPoint {
    type Output = FixedPoint;
    fn sub(self, rhs: FixedPoint) -> FixedPoint {
        FixedPoint(self.0.checked_sub(rhs.0).unwrap_or(0))
    }
}
impl Mul for FixedPoint {
    type Output = FixedPoint;
    fn mul(self, rhs: FixedPoint) -> FixedPoint {
        // Use checked arithmetic to prevent overflow
        let result = self
            .0
            .checked_mul(rhs.0)
            .and_then(|r| r.checked_div(Self::DECIMALS))
            .unwrap_or(u128::MAX);
        FixedPoint(result)
    }
}
impl Div for FixedPoint {
    type Output = FixedPoint;
    fn div(self, rhs: FixedPoint) -> FixedPoint {
        // Use checked arithmetic to prevent overflow
        let result = self
            .0
            .checked_mul(Self::DECIMALS)
            .and_then(|r| r.checked_div(rhs.0))
            .unwrap_or(u128::MAX);
        FixedPoint(result)
    }
}

// Integer interop
impl Mul<u128> for FixedPoint {
    type Output = FixedPoint;
    fn mul(self, rhs: u128) -> FixedPoint {
        FixedPoint(self.0.checked_mul(rhs).unwrap_or(u128::MAX))
    }
}
impl Mul<FixedPoint> for u128 {
    type Output = FixedPoint;
    fn mul(self, rhs: FixedPoint) -> FixedPoint {
        FixedPoint(self.checked_mul(rhs.0).unwrap_or(u128::MAX))
    }
}
impl Div<u128> for FixedPoint {
    type Output = FixedPoint;
    fn div(self, rhs: u128) -> FixedPoint {
        FixedPoint(self.0 / rhs)
    }
}

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

    #[test]
    fn test_parse_string() {
        let fp = FixedPoint::from_str("123.456789").unwrap();
        assert_eq!(fp.to_decimal_string(), "123.456789");
    }
    #[test]
    fn test_parse_integer_string() {
        let fp = FixedPoint::from_str("42").unwrap();
        assert_eq!(fp.to_decimal_string(), "42");
    }
    #[test]
    fn test_f64_conversion() {
        let fp = FixedPoint::from_str("0.123456789").unwrap();
        let f = fp.to_f64();
        let fp2 = FixedPoint::from_f64(f);
        let diff = (fp.as_scaled() as i128 - fp2.as_scaled() as i128).abs();
        assert!(diff <= 1);
    }
    #[test]
    fn test_arithmetic_fixedpoint() {
        let a = FixedPoint::from_str("2").unwrap();
        let b = FixedPoint::from_str("3").unwrap();
        assert_eq!((a + b).to_decimal_string(), "5");
        assert_eq!((b - a).to_decimal_string(), "1");
        assert_eq!((a * b).to_decimal_string(), "6");
        assert_eq!((b / a).to_decimal_string(), "1.5");
    }
    #[test]
    fn test_integer_interop() {
        let a = FixedPoint::from_str("2").unwrap();
        assert_eq!((a * 3u128).to_decimal_string(), "6");
        assert_eq!((3u128 * a).to_decimal_string(), "6");
        assert_eq!(((3u128 * a) / 2u128).to_decimal_string(), "3");
    }
    #[test]
    fn test_serde_string() {
        let a = FixedPoint::from_str("123.456").unwrap();
        let json = serde_json::to_string(&a).unwrap();
        assert_eq!(json, "\"123.456\"");
        let b: FixedPoint = serde_json::from_str(&json).unwrap();
        assert_eq!(a, b);
    }
    #[test]
    fn test_serde_struct() {
        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        struct Rates {
            token_a: FixedPoint,
            token_b: FixedPoint,
        }
        let rates = Rates {
            token_a: FixedPoint::from_str("0.01").unwrap(),
            token_b: FixedPoint::from_str("150000.1234").unwrap(),
        };
        let json = serde_json::to_string(&rates).unwrap();
        let parsed: Rates = serde_json::from_str(&json).unwrap();
        assert_eq!(rates, parsed);
    }
    #[test]
    fn test_raw_integer_deserialization() {
        let json = r#"1000000000000000000"#;
        let fp: FixedPoint = serde_json::from_str(json).unwrap();
        assert_eq!(fp.as_scaled(), 1_000_000_000_000_000_000);
    }
    #[test]
    fn test_round_trip() {
        let a = FixedPoint::from_str("98765.4321").unwrap();
        let json = serde_json::to_string(&a).unwrap();
        let b: FixedPoint = serde_json::from_str(&json).unwrap();
        assert_eq!(a, b);
    }

    // Edge cases
    #[test]
    fn test_smallest_fraction() {
        let fp = FixedPoint::from_str("0.000000000000000001").unwrap();
        assert_eq!(fp.as_scaled(), 1);
    }
    #[test]
    fn test_zero() {
        let fp = FixedPoint::from_str("0").unwrap();
        assert_eq!(fp.as_scaled(), 0);
    }
    #[test]
    fn test_large_number() {
        let max_val = u128::MAX / FixedPoint::DECIMALS;
        let fp = FixedPoint::from_scaled(max_val * FixedPoint::DECIMALS);
        assert_eq!(fp.as_scaled(), max_val * FixedPoint::DECIMALS);
    }
    #[test]
    #[should_panic]
    fn test_overflow_add() {
        let a = FixedPoint(u128::MAX);
        let b = FixedPoint(1);
        let _ = a + b;
    }
    #[test]
    #[should_panic]
    fn test_overflow_mul() {
        let a = FixedPoint(u128::MAX / 2);
        let b = FixedPoint(3);
        let _ = a * b;
    }
    #[test]
    fn test_fraction_precision() {
        let a = FixedPoint::from_str("0.000000000000000001").unwrap();
        let b = FixedPoint::from_scaled(FixedPoint::DECIMALS);
        let c = a * b;
        assert_eq!(c.as_scaled(), 1);
    }
    #[test]
    fn test_fraction_rounding() {
        let res = FixedPoint::from_str("0.0000000000000000001");
        assert!(res.is_err());
    }

    #[test]
    fn test_wei_conversion() {
        let fp = FixedPoint::from_wei(1_000_000_000_000_000_000, 18); // 1 ETH in wei
        assert_eq!(fp.to_decimal_string(), "1");

        let fp2 = FixedPoint::from_wei(1_000_000, 6); // 1 USDC in wei (6 decimals)
        assert_eq!(fp2.to_decimal_string(), "1");

        let fp3 = FixedPoint::from_wei(100_000_000, 8); // 1 WBTC in wei (8 decimals)
        assert_eq!(fp3.to_decimal_string(), "1");
    }

    #[test]
    fn test_bigint_conversion() {
        let bigint = BigUint::from(1_000_000_000_000_000_000u128);
        let fp = FixedPoint::from_bigint(&bigint, 18);
        assert_eq!(fp.to_decimal_string(), "1");

        let bigint2 = BigUint::from(1_000_000u128);
        let fp2 = FixedPoint::from_bigint(&bigint2, 6);
        assert_eq!(fp2.to_decimal_string(), "1");
    }

    #[test]
    fn test_f64_with_decimals() {
        let fp = FixedPoint::from_f64_with_decimals(1.5, 18);
        assert_eq!(fp.to_decimal_string(), "1.5");

        let fp2 = FixedPoint::from_f64_with_decimals(0.01, 18);
        assert_eq!(fp2.to_decimal_string(), "0.01");
    }
}