kabu_types_entities/
swap.rs

1use std::fmt::{Display, Formatter};
2use std::sync::Arc;
3
4use crate::{PoolId, PoolWrapper, SwapLine, SwapStep, Token};
5use alloy_primitives::{Address, U256};
6
7#[derive(Clone, Debug)]
8pub enum Swap {
9    None,
10    ExchangeSwapLine(SwapLine),
11    BackrunSwapSteps((SwapStep, SwapStep)),
12    BackrunSwapLine(SwapLine),
13    Multiple(Vec<Swap>),
14}
15
16impl Display for Swap {
17    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
18        match self {
19            Swap::ExchangeSwapLine(path) => write!(f, "{path}"),
20            Swap::BackrunSwapLine(path) => write!(f, "{path}"),
21            Swap::BackrunSwapSteps((sp0, sp1)) => write!(f, "{sp0} {sp1}"),
22            Swap::Multiple(_) => write!(f, "MULTIPLE_SWAP"),
23            Swap::None => write!(f, "UNKNOWN_SWAP_TYPE"),
24        }
25    }
26}
27
28impl Swap {
29    pub fn to_swap_steps(self: &Swap, multicaller: Address) -> Option<(SwapStep, SwapStep)> {
30        match self {
31            Swap::BackrunSwapLine(swap_line) => swap_line.to_swap_steps(multicaller),
32            Swap::BackrunSwapSteps((sp0, sp1)) => Some((sp0.clone(), sp1.clone())),
33            _ => None,
34        }
35    }
36
37    pub fn arb_profit(&self) -> U256 {
38        match self {
39            Swap::BackrunSwapLine(path) => path.abs_profit(),
40            Swap::BackrunSwapSteps((sp0, sp1)) => SwapStep::arb_profit(sp0, sp1),
41            Swap::Multiple(swap_vec) => swap_vec.iter().map(|x| x.arb_profit()).sum(),
42            Swap::None => U256::ZERO,
43            Swap::ExchangeSwapLine(_) => U256::ZERO,
44        }
45    }
46
47    pub fn pre_estimate_gas(&self) -> u64 {
48        match self {
49            Swap::ExchangeSwapLine(path) => path.gas_used.unwrap_or_default(),
50            Swap::BackrunSwapLine(path) => path.gas_used.unwrap_or_default(),
51            Swap::BackrunSwapSteps((sp0, sp1)) => {
52                sp0.swap_line_vec().iter().map(|i| i.gas_used.unwrap_or_default()).sum::<u64>()
53                    + sp1.swap_line_vec().iter().map(|i| i.gas_used.unwrap_or_default()).sum::<u64>()
54            }
55            Swap::Multiple(swap_vec) => swap_vec.iter().map(|x| x.pre_estimate_gas()).sum(),
56            Swap::None => 0,
57        }
58    }
59
60    pub fn arb_profit_eth(&self) -> U256 {
61        match self {
62            Swap::ExchangeSwapLine(_) => U256::ZERO,
63            Swap::BackrunSwapLine(path) => path.abs_profit_eth(),
64            Swap::BackrunSwapSteps((sp0, sp1)) => SwapStep::arb_profit_eth(sp0, sp1),
65            Swap::Multiple(swap_vec) => swap_vec.iter().map(|x| x.arb_profit_eth()).sum(),
66            Swap::None => U256::ZERO,
67        }
68    }
69
70    pub fn get_first_token(&self) -> Option<&Arc<Token>> {
71        match self {
72            Swap::ExchangeSwapLine(swap_path) => swap_path.get_first_token(),
73            Swap::BackrunSwapLine(swap_path) => swap_path.get_first_token(),
74            Swap::BackrunSwapSteps((sp0, _sp1)) => sp0.get_first_token(),
75            Swap::Multiple(_) => None,
76            Swap::None => None,
77        }
78    }
79
80    pub fn get_pool_id_vec(&self) -> Vec<PoolId> {
81        match self {
82            Swap::ExchangeSwapLine(swap_line) => swap_line.pools().iter().map(|item| item.get_pool_id()).collect(),
83            Swap::BackrunSwapLine(swap_line) => swap_line.pools().iter().map(|item| item.get_pool_id()).collect(),
84            Swap::BackrunSwapSteps((sp0, sp1)) => {
85                let mut swap_line_vec = sp0.swap_line_vec().clone();
86                swap_line_vec.extend(sp1.swap_line_vec().clone());
87                swap_line_vec.iter().flat_map(|item| item.pools().iter().map(|p| p.get_pool_id()).collect::<Vec<_>>()).collect()
88            }
89            Swap::Multiple(swap_vec) => swap_vec.iter().flat_map(|x| x.get_pool_id_vec()).collect(),
90            Swap::None => Vec::new(),
91        }
92    }
93
94    pub fn get_pool_address_vec(&self) -> Vec<PoolId> {
95        match self {
96            Swap::ExchangeSwapLine(swap_line) => swap_line.pools().iter().map(|item| item.get_address()).collect(),
97            Swap::BackrunSwapLine(swap_line) => swap_line.pools().iter().map(|item| item.get_address()).collect(),
98            Swap::BackrunSwapSteps((sp0, sp1)) => {
99                let mut swap_line_vec = sp0.swap_line_vec().clone();
100                swap_line_vec.extend(sp1.swap_line_vec().clone());
101                swap_line_vec.iter().flat_map(|item| item.pools().iter().map(|p| p.get_address()).collect::<Vec<_>>()).collect()
102            }
103            Swap::Multiple(swap_vec) => swap_vec.iter().flat_map(|x| x.get_pool_address_vec()).collect(),
104            Swap::None => Vec::new(),
105        }
106    }
107
108    pub fn get_pools_vec(&self) -> Vec<PoolWrapper> {
109        match self {
110            Swap::ExchangeSwapLine(swap_line) => swap_line.pools().clone(),
111            Swap::BackrunSwapLine(swap_line) => swap_line.pools().clone(),
112            Swap::BackrunSwapSteps((sp0, sp1)) => {
113                let mut swap_line_vec = sp0.swap_line_vec().clone();
114                swap_line_vec.extend(sp1.swap_line_vec().clone());
115                swap_line_vec.iter().flat_map(|item| item.pools().iter().cloned()).collect::<Vec<_>>().to_vec()
116            }
117            Swap::Multiple(swap_vec) => swap_vec.iter().flat_map(|x| x.get_pools_vec()).collect(),
118            Swap::None => Vec::new(),
119        }
120    }
121}
kabu_types_entities/swap.rs

kabu_types_entities/
swap.rs
