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 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
89pub(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 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 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}