kabu_defi_pools/loaders/
mod.rs

1mod curve;
2mod maverick;
3mod uniswap2;
4mod uniswap3;
5
6use crate::loaders::curve::CurvePoolLoader;
7use alloy::providers::network::Ethereum;
8use alloy::providers::{Network, Provider};
9use kabu_types_blockchain::{KabuDataTypes, KabuDataTypesEVM, KabuDataTypesEthereum};
10use kabu_types_entities::pool_config::PoolsLoadingConfig;
11use kabu_types_entities::{PoolClass, PoolLoader, PoolLoaders};
12pub use maverick::MaverickPoolLoader;
13pub use uniswap2::UniswapV2PoolLoader;
14pub use uniswap3::UniswapV3PoolLoader;
15
16/// creates  pool loader and imports necessary crates
17#[macro_export]
18macro_rules! pool_loader {
19    // This will match the input like MaverickPoolLoader
20    ($name:ident) => {
21        use alloy::providers::{Network, Provider};
22        use std::marker::PhantomData;
23
24        #[derive(Clone)]
25
26        pub struct $name<P, N, LDT = KabuDataTypesEthereum>
27        where
28            N: Network,
29            P: Provider<N> + Clone,
30            LDT: KabuDataTypes,
31        {
32            provider: Option<P>,
33            phantom_data: PhantomData<(P, N, LDT)>,
34        }
35
36        #[allow(dead_code)]
37        impl<P, N, LDT> $name<P, N, LDT>
38        where
39            N: Network,
40            P: Provider<N> + Clone,
41            LDT: KabuDataTypes,
42        {
43            pub fn new() -> Self {
44                Self::default()
45            }
46
47            pub fn with_provider(provder: P) -> Self {
48                Self { provider: Some(provder), phantom_data: PhantomData }
49            }
50        }
51
52        impl<P, N, LDT> Default for $name<P, N, LDT>
53        where
54            N: Network,
55            P: Provider<N> + Clone,
56            LDT: KabuDataTypes,
57        {
58            fn default() -> Self {
59                Self { provider: None, phantom_data: PhantomData }
60            }
61        }
62    };
63}
64
65pub struct PoolLoadersBuilder<P, N = Ethereum, LDT = KabuDataTypesEthereum>
66where
67    N: Network,
68    P: Provider<N> + 'static,
69    LDT: KabuDataTypes,
70{
71    inner: PoolLoaders<P, N, LDT>,
72}
73
74impl<P, N, LDT> PoolLoadersBuilder<P, N, LDT>
75where
76    N: Network,
77    P: Provider<N> + 'static,
78    LDT: KabuDataTypes,
79{
80    pub fn new() -> PoolLoadersBuilder<P, N, LDT> {
81        PoolLoadersBuilder { inner: PoolLoaders::<P, N, LDT>::new() }
82    }
83
84    pub fn with_provider<NP: Provider<N>>(self, provider: NP) -> PoolLoadersBuilder<NP, N, LDT> {
85        PoolLoadersBuilder { inner: self.inner.with_provider(provider) }
86    }
87
88    pub fn with_config(self, config: PoolsLoadingConfig) -> Self {
89        Self { inner: self.inner.with_config(config) }
90    }
91
92    pub fn add_loader<L: PoolLoader<P, N, LDT> + Send + Sync + Clone + 'static>(self, pool_class: PoolClass, pool_loader: L) -> Self {
93        Self { inner: self.inner.add_loader(pool_class, pool_loader) }
94    }
95
96    pub fn build(self) -> PoolLoaders<P, N, LDT> {
97        self.inner
98    }
99}
100
101impl<P, N, LDT> Default for PoolLoadersBuilder<P, N, LDT>
102where
103    N: Network,
104    P: Provider<N> + 'static,
105    LDT: KabuDataTypes,
106{
107    fn default() -> Self {
108        Self { inner: PoolLoaders::new() }
109    }
110}
111
112impl<P, N, LDT> PoolLoadersBuilder<P, N, LDT>
113where
114    N: Network,
115    P: Provider<N> + Clone + 'static,
116    LDT: KabuDataTypesEVM + 'static,
117{
118    pub fn default_pool_loaders(provider: P, config: PoolsLoadingConfig) -> PoolLoaders<P, N, LDT>
119    where
120        P: Provider<N> + Clone,
121    {
122        PoolLoadersBuilder::<P, N, LDT>::new()
123            .with_provider(provider.clone())
124            .with_config(config)
125            .add_loader(PoolClass::Maverick, MaverickPoolLoader::with_provider(provider.clone()))
126            .add_loader(PoolClass::UniswapV2, UniswapV2PoolLoader::with_provider(provider.clone()))
127            .add_loader(PoolClass::UniswapV3, UniswapV3PoolLoader::with_provider(provider.clone()))
128            .add_loader(PoolClass::Curve, CurvePoolLoader::with_provider(provider.clone()))
129            .build()
130    }
131}