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