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
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 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 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}