Skip to main content

tycho_simulation/evm/protocol/aerodrome_v1/
state.rs

1use std::{any::Any, collections::HashMap};
2
3use alloy::primitives::U256;
4use num_bigint::BigUint;
5use num_traits::Zero;
6use serde::{Deserialize, Serialize};
7use tycho_common::{
8    dto::ProtocolStateDelta,
9    models::token::Token,
10    simulation::{
11        errors::{SimulationError, TransitionError},
12        protocol_sim::{
13            Balances, GetAmountOutResult, PoolSwap, ProtocolSim, QueryPoolSwapParams,
14            SwapConstraint,
15        },
16    },
17    Bytes,
18};
19
20use super::solidly_stable::{StableMath, StablePool};
21use crate::evm::protocol::{
22    cpmm::protocol::{cpmm_fee, cpmm_get_limits, cpmm_spot_price, cpmm_swap_to_price, ProtocolFee},
23    safe_math::{safe_add_u256, safe_div_u256, safe_mul_u256, safe_sub_u256},
24    u256_num::{biguint_to_u256, u256_to_biguint},
25    utils::add_fee_markup,
26};
27
28const FEE_PRECISION_BPS: u32 = 10_000;
29const FEE_PRECISION: U256 = U256::from_limbs([10_000, 0, 0, 0]);
30const AERODROME_V1_STABLE_FEE_BPS: u32 = 5;
31const AERODROME_V1_VOLATILE_FEE_BPS: u32 = 30;
32const AERODROME_V1_ZERO_FEE_INDICATOR_BPS: u32 = 420;
33
34#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
35pub struct AerodromeV1State {
36    pub reserve0: U256,
37    pub reserve1: U256,
38    pub stable: bool,
39    pub fee: u32,
40    pub decimals0: u8,
41    pub decimals1: u8,
42}
43
44impl AerodromeV1State {
45    /// Creates a new instance of `AerodromeV1State` with the given reserves and raw fee.
46    pub fn new(
47        reserve0: U256,
48        reserve1: U256,
49        stable: bool,
50        fee: u32,
51        decimals0: u8,
52        decimals1: u8,
53    ) -> Self {
54        Self { reserve0, reserve1, stable, fee, decimals0, decimals1 }
55    }
56
57    fn default_fee_bps(&self) -> u32 {
58        if self.stable {
59            AERODROME_V1_STABLE_FEE_BPS
60        } else {
61            AERODROME_V1_VOLATILE_FEE_BPS
62        }
63    }
64
65    fn resolved_fee_bps(&self) -> u32 {
66        if self.fee == AERODROME_V1_ZERO_FEE_INDICATOR_BPS {
67            0
68        } else if self.fee != 0 {
69            self.fee
70        } else {
71            self.default_fee_bps()
72        }
73    }
74
75    fn protocol_fee(&self) -> Result<ProtocolFee, SimulationError> {
76        let fee_bps = self.resolved_fee_bps();
77
78        if fee_bps > FEE_PRECISION_BPS {
79            return Err(SimulationError::FatalError(format!(
80                "Invalid resolved fee value {}, expected <= {} bps",
81                fee_bps, FEE_PRECISION_BPS
82            )));
83        }
84
85        Ok(ProtocolFee::new(U256::from(FEE_PRECISION_BPS - fee_bps), FEE_PRECISION))
86    }
87}
88
89/// Output of a Solidly volatile (`x * y = k`) swap, as the pool's `getAmountOut`.
90///
91/// The pool first computes `floor(amount_in * fee / 10000)`, subtracts that fee from `amount_in`,
92/// and only then applies the constant-product formula. Reusing `cpmm_get_amount_out` would instead
93/// fold the fee into the numerator/denominator as `amount_in * (10000 - fee) / 10000`, which is
94/// algebraically equivalent over reals but not under Solidity integer division. That rounding
95/// difference is observable on-chain, so we mirror the contract implementation here.
96pub(crate) fn volatile_get_amount_out(
97    amount_in: U256,
98    reserve_in: U256,
99    reserve_out: U256,
100    fee_bps: u32,
101) -> Result<U256, SimulationError> {
102    if amount_in == U256::ZERO {
103        return Err(SimulationError::InvalidInput("Amount in cannot be zero".to_string(), None));
104    }
105
106    if reserve_in == U256::ZERO || reserve_out == U256::ZERO {
107        return Err(SimulationError::RecoverableError("No liquidity".to_string()));
108    }
109
110    let fee_amount = safe_div_u256(safe_mul_u256(amount_in, U256::from(fee_bps))?, FEE_PRECISION)?;
111    let amount_in_after_fee = safe_sub_u256(amount_in, fee_amount)?;
112    let numerator = safe_mul_u256(amount_in_after_fee, reserve_out)?;
113    let denominator = safe_add_u256(reserve_in, amount_in_after_fee)?;
114
115    safe_div_u256(numerator, denominator)
116}
117
118fn token_decimals(token: &Token) -> Result<u8, SimulationError> {
119    u8::try_from(token.decimals).map_err(|e| {
120        SimulationError::InvalidInput(
121            format!("Token {} decimals out of range: {e}", token.address),
122            None,
123        )
124    })
125}
126
127#[typetag::serde]
128impl ProtocolSim for AerodromeV1State {
129    fn fee(&self) -> f64 {
130        cpmm_fee(self.resolved_fee_bps())
131    }
132
133    fn spot_price(&self, base: &Token, quote: &Token) -> Result<f64, SimulationError> {
134        let price = cpmm_spot_price(base, quote, self.reserve0, self.reserve1)?;
135        Ok(add_fee_markup(price, self.fee()))
136    }
137
138    fn get_amount_out(
139        &self,
140        amount_in: BigUint,
141        token_in: &Token,
142        token_out: &Token,
143    ) -> Result<GetAmountOutResult, SimulationError> {
144        let amount_in = biguint_to_u256(&amount_in);
145        let zero2one = token_in.address < token_out.address;
146        let amount_out = if self.stable {
147            let decimals_in = token_decimals(token_in)?;
148            let decimals_out = token_decimals(token_out)?;
149            StablePool {
150                reserve0: self.reserve0,
151                reserve1: self.reserve1,
152                decimals0: if zero2one { decimals_in } else { decimals_out },
153                decimals1: if zero2one { decimals_out } else { decimals_in },
154                math: StableMath::Checked,
155            }
156            .get_amount_out(amount_in, zero2one, self.resolved_fee_bps())?
157        } else {
158            let (reserve_in, reserve_out) = if zero2one {
159                (self.reserve0, self.reserve1)
160            } else {
161                (self.reserve1, self.reserve0)
162            };
163            volatile_get_amount_out(amount_in, reserve_in, reserve_out, self.resolved_fee_bps())?
164        };
165        let mut new_state = self.clone();
166        let (reserve0_mut, reserve1_mut) = (&mut new_state.reserve0, &mut new_state.reserve1);
167        if zero2one {
168            *reserve0_mut = safe_add_u256(self.reserve0, amount_in)?;
169            *reserve1_mut = safe_sub_u256(self.reserve1, amount_out)?;
170        } else {
171            *reserve0_mut = safe_sub_u256(self.reserve0, amount_out)?;
172            *reserve1_mut = safe_add_u256(self.reserve1, amount_in)?;
173        };
174        Ok(GetAmountOutResult::new(
175            u256_to_biguint(amount_out),
176            BigUint::from(120_000u32),
177            Box::new(new_state),
178        ))
179    }
180
181    fn get_limits(
182        &self,
183        sell_token: Bytes,
184        buy_token: Bytes,
185    ) -> Result<(BigUint, BigUint), SimulationError> {
186        if self.stable {
187            StablePool {
188                reserve0: self.reserve0,
189                reserve1: self.reserve1,
190                decimals0: self.decimals0,
191                decimals1: self.decimals1,
192                math: StableMath::Checked,
193            }
194            .get_limits(&sell_token, &buy_token)
195        } else {
196            cpmm_get_limits(
197                &sell_token,
198                &buy_token,
199                self.reserve0,
200                self.reserve1,
201                self.resolved_fee_bps(),
202            )
203        }
204    }
205
206    fn delta_transition(
207        &mut self,
208        delta: ProtocolStateDelta,
209        _tokens: &HashMap<Bytes, Token>,
210        _balances: &Balances,
211    ) -> Result<(), TransitionError> {
212        if let Some(reserve0) = delta.updated_attributes.get("reserve0") {
213            self.reserve0 = U256::from_be_slice(reserve0);
214        }
215        if let Some(reserve1) = delta.updated_attributes.get("reserve1") {
216            self.reserve1 = U256::from_be_slice(reserve1);
217        }
218        if let Some(fee) = delta.updated_attributes.get("fee") {
219            self.fee = u32::try_from(fee.clone())?;
220            let resolved_fee_bps = self.resolved_fee_bps();
221            if resolved_fee_bps > FEE_PRECISION_BPS {
222                return Err(TransitionError::DecodeError(format!(
223                    "Invalid resolved fee value {}, expected <= {} bps",
224                    resolved_fee_bps, FEE_PRECISION_BPS
225                )));
226            }
227        }
228        Ok(())
229    }
230
231    fn query_pool_swap(&self, params: &QueryPoolSwapParams) -> Result<PoolSwap, SimulationError> {
232        match params.swap_constraint() {
233            SwapConstraint::PoolTargetPrice {
234                target: price,
235                tolerance: _,
236                min_amount_in: _,
237                max_amount_in: _,
238            } => {
239                let zero2one = params.token_in().address < params.token_out().address;
240                let (reserve_in, reserve_out) = if zero2one {
241                    (self.reserve0, self.reserve1)
242                } else {
243                    (self.reserve1, self.reserve0)
244                };
245
246                let (amount_in, _) =
247                    cpmm_swap_to_price(reserve_in, reserve_out, price, self.protocol_fee()?)?;
248                if amount_in.is_zero() {
249                    return Ok(PoolSwap::new(
250                        BigUint::ZERO,
251                        BigUint::ZERO,
252                        Box::new(self.clone()),
253                        None,
254                    ));
255                }
256
257                let res =
258                    self.get_amount_out(amount_in.clone(), params.token_in(), params.token_out())?;
259                Ok(PoolSwap::new(amount_in, res.amount, res.new_state, None))
260            }
261            SwapConstraint::TradeLimitPrice { .. } => Err(SimulationError::InvalidInput(
262                "AerodromeV1State does not support TradeLimitPrice constraint in query_pool_swap"
263                    .to_string(),
264                None,
265            )),
266        }
267    }
268
269    fn clone_box(&self) -> Box<dyn ProtocolSim> {
270        Box::new(self.clone())
271    }
272
273    fn as_any(&self) -> &dyn Any {
274        self
275    }
276
277    fn as_any_mut(&mut self) -> &mut dyn Any {
278        self
279    }
280
281    fn eq(&self, other: &dyn ProtocolSim) -> bool {
282        if let Some(other_state) = other.as_any().downcast_ref::<Self>() {
283            self.reserve0 == other_state.reserve0 &&
284                self.reserve1 == other_state.reserve1 &&
285                self.stable == other_state.stable &&
286                self.fee == other_state.fee &&
287                self.decimals0 == other_state.decimals0 &&
288                self.decimals1 == other_state.decimals1
289        } else {
290            false
291        }
292    }
293}
294
295#[cfg(test)]
296mod tests {
297    use std::{
298        collections::{HashMap, HashSet},
299        str::FromStr,
300    };
301
302    use alloy::primitives::U256;
303    use num_bigint::BigUint;
304    use num_traits::One;
305    use tycho_common::{
306        dto::ProtocolStateDelta,
307        hex_bytes::Bytes,
308        models::{token::Token, Chain},
309        simulation::{
310            errors::TransitionError,
311            protocol_sim::{Balances, ProtocolSim},
312        },
313    };
314
315    use super::{AerodromeV1State, AERODROME_V1_ZERO_FEE_INDICATOR_BPS};
316
317    fn token_0() -> Token {
318        Token::new(&Bytes::from([0_u8; 20]), "T0", 18, 0, &[Some(10_000)], Chain::Ethereum, 100)
319    }
320
321    fn token_1() -> Token {
322        let mut addr = [0_u8; 20];
323        addr[19] = 1;
324        Token::new(&Bytes::from(addr), "T1", 18, 0, &[Some(10_000)], Chain::Ethereum, 100)
325    }
326
327    fn base_usdc() -> Token {
328        Token::new(
329            &Bytes::from_str("0x833589fcd6edb6e08f4c7c32d4f71b54bda02913").unwrap(),
330            "USDC",
331            6,
332            0,
333            &[Some(10_000)],
334            Chain::Base,
335            100,
336        )
337    }
338
339    fn base_usdt() -> Token {
340        Token::new(
341            &Bytes::from_str("0xfde4c96c8593536e31f229ea8f37b2ada2699bb2").unwrap(),
342            "USDT",
343            6,
344            0,
345            &[Some(10_000)],
346            Chain::Base,
347            100,
348        )
349    }
350
351    fn base_aero() -> Token {
352        Token::new(
353            &Bytes::from_str("0x940181a94a35a4569e4529a3cdfb74e38fd98631").unwrap(),
354            "AERO",
355            18,
356            0,
357            &[Some(10_000)],
358            Chain::Base,
359            100,
360        )
361    }
362
363    #[test]
364    fn test_get_amount_out_matches_real_volatile_pool_on_chain() {
365        // Base Aerodrome volatile USDC/AERO pool 0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d
366        // at block 44,628,997:
367        // - fee: 30 bps
368        // - reserves: 12_130_133_468_200 / 33_517_464_576_714_176_786_208_401
369        // - getAmountOut(26_225_348_558, USDC) = 72_091_968_892_551_547_616_192
370        let state = AerodromeV1State::new(
371            U256::from_str("12130133468200").unwrap(),
372            U256::from_str("33517464576714176786208401").unwrap(),
373            false,
374            30,
375            6,
376            18,
377        );
378        let out = state
379            .get_amount_out(BigUint::from_str("26225348558").unwrap(), &base_usdc(), &base_aero())
380            .expect("swap should succeed");
381
382        assert_eq!(out.amount, BigUint::from_str("72091968892551547616192").unwrap());
383    }
384
385    #[test]
386    fn test_delta_transition_supports_fee_only_update() {
387        let mut state = AerodromeV1State::new(
388            U256::from(2_000_000u32),
389            U256::from(1_000_000u32),
390            false,
391            30,
392            18,
393            18,
394        );
395        let delta = ProtocolStateDelta {
396            component_id: "pool".to_string(),
397            updated_attributes: HashMap::from([(
398                "fee".to_string(),
399                Bytes::from(5_u32.to_be_bytes().to_vec()),
400            )]),
401            deleted_attributes: HashSet::new(),
402        };
403
404        state
405            .delta_transition(delta, &HashMap::new(), &Balances::default())
406            .expect("fee-only update should succeed");
407        assert_eq!(state.fee, 5);
408        assert_eq!(state.reserve0, U256::from(2_000_000u32));
409        assert_eq!(state.reserve1, U256::from(1_000_000u32));
410    }
411
412    #[test]
413    fn test_delta_transition_rejects_invalid_fee() {
414        let mut state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 30, 18, 18);
415        let delta = ProtocolStateDelta {
416            component_id: "pool".to_string(),
417            updated_attributes: HashMap::from([(
418                "fee".to_string(),
419                Bytes::from(10_101_u32.to_be_bytes().to_vec()),
420            )]),
421            deleted_attributes: HashSet::new(),
422        };
423
424        let err = state
425            .delta_transition(delta, &HashMap::new(), &Balances::default())
426            .expect_err("invalid fee should fail");
427        assert!(matches!(err, TransitionError::DecodeError(_)));
428    }
429
430    #[test]
431    fn test_fee_fn_returns_fraction() {
432        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 30, 18, 18);
433        assert_eq!(state.fee(), 0.003);
434        let state = AerodromeV1State::new(U256::ONE, U256::ONE, true, 5, 18, 18);
435        assert_eq!(state.fee(), 0.0005);
436    }
437
438    #[test]
439    fn test_protocol_fee_accepts_zero_fee_indicator() {
440        let state = AerodromeV1State::new(
441            U256::ONE,
442            U256::ONE,
443            true,
444            AERODROME_V1_ZERO_FEE_INDICATOR_BPS,
445            18,
446            18,
447        );
448        assert!(state.protocol_fee().is_ok());
449        assert_eq!(state.fee(), 0.0);
450    }
451
452    #[test]
453    fn test_protocol_fee_rejects_out_of_range() {
454        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 10_001, 18, 18);
455        assert!(state.protocol_fee().is_err());
456    }
457
458    #[test]
459    fn test_fee_defaults_when_custom_fee_missing() {
460        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 0, 18, 18);
461        assert_eq!(state.fee(), 0.003);
462        let stable_state = AerodromeV1State::new(U256::ONE, U256::ONE, true, 0, 18, 18);
463        assert_eq!(stable_state.fee(), 0.0005);
464    }
465
466    #[test]
467    fn test_get_amount_out_no_fee() {
468        let state = AerodromeV1State::new(
469            U256::from(10_000u32),
470            U256::from(10_000u32),
471            false,
472            AERODROME_V1_ZERO_FEE_INDICATOR_BPS,
473            18,
474            18,
475        );
476        let out = state
477            .get_amount_out(BigUint::one(), &token_0(), &token_1())
478            .expect("swap should succeed");
479        assert_eq!(
480            out.amount,
481            BigUint::one() * BigUint::from(10_000u32) / BigUint::from(10_001u32)
482        );
483    }
484
485    #[test]
486    fn test_get_amount_out_stable_uses_cfmm_curve() {
487        let state = AerodromeV1State::new(
488            U256::from(2_642_455_102_346_776_307_825u128),
489            U256::from(3_320_301_880_379_841_502_303u128),
490            true,
491            5,
492            18,
493            18,
494        );
495
496        let out = state
497            .get_amount_out(BigUint::from(2_000_000_000_000_000_000u128), &token_0(), &token_1())
498            .expect("stable swap should succeed");
499
500        assert_eq!(out.amount, BigUint::from(2_004_830_151_166_915_124u128));
501    }
502
503    #[test]
504    fn test_get_amount_out_matches_real_stable_pool_on_chain() {
505        // Base Aerodrome stable USDC/USDT pool 0x96508AE8037c6bD16162620187691F1c1e3e07C1
506        // at block 44,629,732:
507        // - fee: 5 bps
508        // - reserves: 2_170_141_538 / 2_029_164_659
509        // - getAmountOut(123_456_789, USDC) = 123_320_126
510        let state = AerodromeV1State::new(
511            U256::from(2_170_141_538u32),
512            U256::from(2_029_164_659u32),
513            true,
514            5,
515            6,
516            6,
517        );
518
519        let out = state
520            .get_amount_out(BigUint::from(123_456_789u32), &base_usdc(), &base_usdt())
521            .expect("stable swap should succeed");
522
523        assert_eq!(out.amount, BigUint::from(123_320_126u32));
524    }
525}