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
118#[typetag::serde]
119impl ProtocolSim for AerodromeV1State {
120    fn fee(&self) -> f64 {
121        cpmm_fee(self.resolved_fee_bps())
122    }
123
124    fn spot_price(&self, base: &Token, quote: &Token) -> Result<f64, SimulationError> {
125        let price = cpmm_spot_price(base, quote, self.reserve0, self.reserve1)?;
126        Ok(add_fee_markup(price, self.fee()))
127    }
128
129    fn get_amount_out(
130        &self,
131        amount_in: BigUint,
132        token_in: &Token,
133        token_out: &Token,
134    ) -> Result<GetAmountOutResult, SimulationError> {
135        let amount_in = biguint_to_u256(&amount_in);
136        let zero2one = token_in.address < token_out.address;
137        let amount_out = if self.stable {
138            StablePool {
139                reserve0: self.reserve0,
140                reserve1: self.reserve1,
141                decimals0: if zero2one {
142                    token_in.decimals as u8
143                } else {
144                    token_out.decimals as u8
145                },
146                decimals1: if zero2one {
147                    token_out.decimals as u8
148                } else {
149                    token_in.decimals as u8
150                },
151                math: StableMath::Checked,
152            }
153            .get_amount_out(amount_in, zero2one, self.resolved_fee_bps())?
154        } else {
155            let (reserve_in, reserve_out) = if zero2one {
156                (self.reserve0, self.reserve1)
157            } else {
158                (self.reserve1, self.reserve0)
159            };
160            volatile_get_amount_out(amount_in, reserve_in, reserve_out, self.resolved_fee_bps())?
161        };
162        let mut new_state = self.clone();
163        let (reserve0_mut, reserve1_mut) = (&mut new_state.reserve0, &mut new_state.reserve1);
164        if zero2one {
165            *reserve0_mut = safe_add_u256(self.reserve0, amount_in)?;
166            *reserve1_mut = safe_sub_u256(self.reserve1, amount_out)?;
167        } else {
168            *reserve0_mut = safe_sub_u256(self.reserve0, amount_out)?;
169            *reserve1_mut = safe_add_u256(self.reserve1, amount_in)?;
170        };
171        Ok(GetAmountOutResult::new(
172            u256_to_biguint(amount_out),
173            BigUint::from(120_000u32),
174            Box::new(new_state),
175        ))
176    }
177
178    fn get_limits(
179        &self,
180        sell_token: Bytes,
181        buy_token: Bytes,
182    ) -> Result<(BigUint, BigUint), SimulationError> {
183        if self.stable {
184            StablePool {
185                reserve0: self.reserve0,
186                reserve1: self.reserve1,
187                decimals0: self.decimals0,
188                decimals1: self.decimals1,
189                math: StableMath::Checked,
190            }
191            .get_limits(sell_token, buy_token)
192        } else {
193            cpmm_get_limits(
194                sell_token,
195                buy_token,
196                self.reserve0,
197                self.reserve1,
198                self.resolved_fee_bps(),
199            )
200        }
201    }
202
203    fn delta_transition(
204        &mut self,
205        delta: ProtocolStateDelta,
206        _tokens: &HashMap<Bytes, Token>,
207        _balances: &Balances,
208    ) -> Result<(), TransitionError> {
209        if let Some(reserve0) = delta.updated_attributes.get("reserve0") {
210            self.reserve0 = U256::from_be_slice(reserve0);
211        }
212        if let Some(reserve1) = delta.updated_attributes.get("reserve1") {
213            self.reserve1 = U256::from_be_slice(reserve1);
214        }
215        if let Some(fee) = delta.updated_attributes.get("fee") {
216            self.fee = u32::from(fee.clone());
217            let resolved_fee_bps = self.resolved_fee_bps();
218            if resolved_fee_bps > FEE_PRECISION_BPS {
219                return Err(TransitionError::DecodeError(format!(
220                    "Invalid resolved fee value {}, expected <= {} bps",
221                    resolved_fee_bps, FEE_PRECISION_BPS
222                )));
223            }
224        }
225        Ok(())
226    }
227
228    fn query_pool_swap(&self, params: &QueryPoolSwapParams) -> Result<PoolSwap, SimulationError> {
229        match params.swap_constraint() {
230            SwapConstraint::PoolTargetPrice {
231                target: price,
232                tolerance: _,
233                min_amount_in: _,
234                max_amount_in: _,
235            } => {
236                let zero2one = params.token_in().address < params.token_out().address;
237                let (reserve_in, reserve_out) = if zero2one {
238                    (self.reserve0, self.reserve1)
239                } else {
240                    (self.reserve1, self.reserve0)
241                };
242
243                let (amount_in, _) =
244                    cpmm_swap_to_price(reserve_in, reserve_out, price, self.protocol_fee()?)?;
245                if amount_in.is_zero() {
246                    return Ok(PoolSwap::new(
247                        BigUint::ZERO,
248                        BigUint::ZERO,
249                        Box::new(self.clone()),
250                        None,
251                    ));
252                }
253
254                let res =
255                    self.get_amount_out(amount_in.clone(), params.token_in(), params.token_out())?;
256                Ok(PoolSwap::new(amount_in, res.amount, res.new_state, None))
257            }
258            SwapConstraint::TradeLimitPrice { .. } => Err(SimulationError::InvalidInput(
259                "AerodromeV1State does not support TradeLimitPrice constraint in query_pool_swap"
260                    .to_string(),
261                None,
262            )),
263        }
264    }
265
266    fn clone_box(&self) -> Box<dyn ProtocolSim> {
267        Box::new(self.clone())
268    }
269
270    fn as_any(&self) -> &dyn Any {
271        self
272    }
273
274    fn as_any_mut(&mut self) -> &mut dyn Any {
275        self
276    }
277
278    fn eq(&self, other: &dyn ProtocolSim) -> bool {
279        if let Some(other_state) = other.as_any().downcast_ref::<Self>() {
280            self.reserve0 == other_state.reserve0 &&
281                self.reserve1 == other_state.reserve1 &&
282                self.stable == other_state.stable &&
283                self.fee == other_state.fee &&
284                self.decimals0 == other_state.decimals0 &&
285                self.decimals1 == other_state.decimals1
286        } else {
287            false
288        }
289    }
290}
291
292#[cfg(test)]
293mod tests {
294    use std::{
295        collections::{HashMap, HashSet},
296        str::FromStr,
297    };
298
299    use alloy::primitives::U256;
300    use num_bigint::BigUint;
301    use num_traits::One;
302    use tycho_common::{
303        dto::ProtocolStateDelta,
304        hex_bytes::Bytes,
305        models::{token::Token, Chain},
306        simulation::{
307            errors::TransitionError,
308            protocol_sim::{Balances, ProtocolSim},
309        },
310    };
311
312    use super::{AerodromeV1State, AERODROME_V1_ZERO_FEE_INDICATOR_BPS};
313
314    fn token_0() -> Token {
315        Token::new(&Bytes::from([0_u8; 20]), "T0", 18, 0, &[Some(10_000)], Chain::Ethereum, 100)
316    }
317
318    fn token_1() -> Token {
319        let mut addr = [0_u8; 20];
320        addr[19] = 1;
321        Token::new(&Bytes::from(addr), "T1", 18, 0, &[Some(10_000)], Chain::Ethereum, 100)
322    }
323
324    fn base_usdc() -> Token {
325        Token::new(
326            &Bytes::from_str("0x833589fcd6edb6e08f4c7c32d4f71b54bda02913").unwrap(),
327            "USDC",
328            6,
329            0,
330            &[Some(10_000)],
331            Chain::Base,
332            100,
333        )
334    }
335
336    fn base_usdt() -> Token {
337        Token::new(
338            &Bytes::from_str("0xfde4c96c8593536e31f229ea8f37b2ada2699bb2").unwrap(),
339            "USDT",
340            6,
341            0,
342            &[Some(10_000)],
343            Chain::Base,
344            100,
345        )
346    }
347
348    fn base_aero() -> Token {
349        Token::new(
350            &Bytes::from_str("0x940181a94a35a4569e4529a3cdfb74e38fd98631").unwrap(),
351            "AERO",
352            18,
353            0,
354            &[Some(10_000)],
355            Chain::Base,
356            100,
357        )
358    }
359
360    #[test]
361    fn test_get_amount_out_matches_real_volatile_pool_on_chain() {
362        // Base Aerodrome volatile USDC/AERO pool 0x6cDcb1C4A4D1C3C6d054b27AC5B77e89eAFb971d
363        // at block 44,628,997:
364        // - fee: 30 bps
365        // - reserves: 12_130_133_468_200 / 33_517_464_576_714_176_786_208_401
366        // - getAmountOut(26_225_348_558, USDC) = 72_091_968_892_551_547_616_192
367        let state = AerodromeV1State::new(
368            U256::from_str("12130133468200").unwrap(),
369            U256::from_str("33517464576714176786208401").unwrap(),
370            false,
371            30,
372            6,
373            18,
374        );
375        let out = state
376            .get_amount_out(BigUint::from_str("26225348558").unwrap(), &base_usdc(), &base_aero())
377            .expect("swap should succeed");
378
379        assert_eq!(out.amount, BigUint::from_str("72091968892551547616192").unwrap());
380    }
381
382    #[test]
383    fn test_delta_transition_supports_fee_only_update() {
384        let mut state = AerodromeV1State::new(
385            U256::from(2_000_000u32),
386            U256::from(1_000_000u32),
387            false,
388            30,
389            18,
390            18,
391        );
392        let delta = ProtocolStateDelta {
393            component_id: "pool".to_string(),
394            updated_attributes: HashMap::from([(
395                "fee".to_string(),
396                Bytes::from(5_u32.to_be_bytes().to_vec()),
397            )]),
398            deleted_attributes: HashSet::new(),
399        };
400
401        state
402            .delta_transition(delta, &HashMap::new(), &Balances::default())
403            .expect("fee-only update should succeed");
404        assert_eq!(state.fee, 5);
405        assert_eq!(state.reserve0, U256::from(2_000_000u32));
406        assert_eq!(state.reserve1, U256::from(1_000_000u32));
407    }
408
409    #[test]
410    fn test_delta_transition_rejects_invalid_fee() {
411        let mut state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 30, 18, 18);
412        let delta = ProtocolStateDelta {
413            component_id: "pool".to_string(),
414            updated_attributes: HashMap::from([(
415                "fee".to_string(),
416                Bytes::from(10_101_u32.to_be_bytes().to_vec()),
417            )]),
418            deleted_attributes: HashSet::new(),
419        };
420
421        let err = state
422            .delta_transition(delta, &HashMap::new(), &Balances::default())
423            .expect_err("invalid fee should fail");
424        assert!(matches!(err, TransitionError::DecodeError(_)));
425    }
426
427    #[test]
428    fn test_fee_fn_returns_fraction() {
429        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 30, 18, 18);
430        assert_eq!(state.fee(), 0.003);
431        let state = AerodromeV1State::new(U256::ONE, U256::ONE, true, 5, 18, 18);
432        assert_eq!(state.fee(), 0.0005);
433    }
434
435    #[test]
436    fn test_protocol_fee_accepts_zero_fee_indicator() {
437        let state = AerodromeV1State::new(
438            U256::ONE,
439            U256::ONE,
440            true,
441            AERODROME_V1_ZERO_FEE_INDICATOR_BPS,
442            18,
443            18,
444        );
445        assert!(state.protocol_fee().is_ok());
446        assert_eq!(state.fee(), 0.0);
447    }
448
449    #[test]
450    fn test_protocol_fee_rejects_out_of_range() {
451        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 10_001, 18, 18);
452        assert!(state.protocol_fee().is_err());
453    }
454
455    #[test]
456    fn test_fee_defaults_when_custom_fee_missing() {
457        let state = AerodromeV1State::new(U256::ONE, U256::ONE, false, 0, 18, 18);
458        assert_eq!(state.fee(), 0.003);
459        let stable_state = AerodromeV1State::new(U256::ONE, U256::ONE, true, 0, 18, 18);
460        assert_eq!(stable_state.fee(), 0.0005);
461    }
462
463    #[test]
464    fn test_get_amount_out_no_fee() {
465        let state = AerodromeV1State::new(
466            U256::from(10_000u32),
467            U256::from(10_000u32),
468            false,
469            AERODROME_V1_ZERO_FEE_INDICATOR_BPS,
470            18,
471            18,
472        );
473        let out = state
474            .get_amount_out(BigUint::one(), &token_0(), &token_1())
475            .expect("swap should succeed");
476        assert_eq!(
477            out.amount,
478            BigUint::one() * BigUint::from(10_000u32) / BigUint::from(10_001u32)
479        );
480    }
481
482    #[test]
483    fn test_get_amount_out_stable_uses_cfmm_curve() {
484        let state = AerodromeV1State::new(
485            U256::from(2_642_455_102_346_776_307_825u128),
486            U256::from(3_320_301_880_379_841_502_303u128),
487            true,
488            5,
489            18,
490            18,
491        );
492
493        let out = state
494            .get_amount_out(BigUint::from(2_000_000_000_000_000_000u128), &token_0(), &token_1())
495            .expect("stable swap should succeed");
496
497        assert_eq!(out.amount, BigUint::from(2_004_830_151_166_915_124u128));
498    }
499
500    #[test]
501    fn test_get_amount_out_matches_real_stable_pool_on_chain() {
502        // Base Aerodrome stable USDC/USDT pool 0x96508AE8037c6bD16162620187691F1c1e3e07C1
503        // at block 44,629,732:
504        // - fee: 5 bps
505        // - reserves: 2_170_141_538 / 2_029_164_659
506        // - getAmountOut(123_456_789, USDC) = 123_320_126
507        let state = AerodromeV1State::new(
508            U256::from(2_170_141_538u32),
509            U256::from(2_029_164_659u32),
510            true,
511            5,
512            6,
513            6,
514        );
515
516        let out = state
517            .get_amount_out(BigUint::from(123_456_789u32), &base_usdc(), &base_usdt())
518            .expect("stable swap should succeed");
519
520        assert_eq!(out.amount, BigUint::from(123_320_126u32));
521    }
522}