nautilus_blockchain/exchanges/
extended.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16use std::{ops::Deref, sync::Arc};
17
18use nautilus_model::defi::{
19    dex::{Dex, SharedDex},
20    rpc::RpcLog,
21};
22
23use crate::{
24    events::{
25        burn::BurnEvent, collect::CollectEvent, flash::FlashEvent, initialize::InitializeEvent,
26        mint::MintEvent, pool_created::PoolCreatedEvent, swap::SwapEvent,
27    },
28    hypersync::HypersyncLog,
29};
30
31/// Extended DEX wrapper that adds provider-specific event parsing capabilities to the domain `Dex` model.
32#[derive(Debug, Clone)]
33pub struct DexExtended {
34    /// The core domain Dex object being extended.
35    pub dex: SharedDex,
36    // === HyperSync parsers ===
37    /// Function to parse pool creation events from HyperSync logs.
38    pub parse_pool_created_event_hypersync_fn:
39        Option<fn(HypersyncLog) -> anyhow::Result<PoolCreatedEvent>>,
40    /// Function to parse initialize events from HyperSync logs.
41    pub parse_initialize_event_hypersync_fn:
42        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<InitializeEvent>>,
43    /// Function to parse swap events from HyperSync logs.
44    pub parse_swap_event_hypersync_fn:
45        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<SwapEvent>>,
46    /// Function to parse mint events from HyperSync logs.
47    pub parse_mint_event_hypersync_fn:
48        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<MintEvent>>,
49    /// Function to parse burn events from HyperSync logs.
50    pub parse_burn_event_hypersync_fn:
51        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<BurnEvent>>,
52    /// Function to parse collect events from HyperSync logs.
53    pub parse_collect_event_hypersync_fn:
54        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<CollectEvent>>,
55    /// Function to parse flash events from HyperSync logs.
56    pub parse_flash_event_hypersync_fn:
57        Option<fn(SharedDex, &HypersyncLog) -> anyhow::Result<FlashEvent>>,
58    // === RPC parsers (hex-decode, standard Ethereum format) ===
59    /// Function to parse pool creation events from RPC logs.
60    pub parse_pool_created_event_rpc_fn: Option<fn(&RpcLog) -> anyhow::Result<PoolCreatedEvent>>,
61    /// Function to parse initialize events from RPC logs.
62    pub parse_initialize_event_rpc_fn:
63        Option<fn(SharedDex, &RpcLog) -> anyhow::Result<InitializeEvent>>,
64    /// Function to parse swap events from RPC logs.
65    pub parse_swap_event_rpc_fn: Option<fn(SharedDex, &RpcLog) -> anyhow::Result<SwapEvent>>,
66    /// Function to parse mint events from RPC logs.
67    pub parse_mint_event_rpc_fn: Option<fn(SharedDex, &RpcLog) -> anyhow::Result<MintEvent>>,
68    /// Function to parse burn events from RPC logs.
69    pub parse_burn_event_rpc_fn: Option<fn(SharedDex, &RpcLog) -> anyhow::Result<BurnEvent>>,
70    /// Function to parse collect events from RPC logs.
71    pub parse_collect_event_rpc_fn: Option<fn(SharedDex, &RpcLog) -> anyhow::Result<CollectEvent>>,
72    /// Function to parse flash events from RPC logs.
73    pub parse_flash_event_rpc_fn: Option<fn(SharedDex, &RpcLog) -> anyhow::Result<FlashEvent>>,
74}
75
76impl DexExtended {
77    /// Creates a new [`DexExtended`] wrapper around a domain `Dex` object.
78    #[must_use]
79    pub fn new(dex: Dex) -> Self {
80        Self {
81            dex: Arc::new(dex),
82            // HyperSync parsers
83            parse_pool_created_event_hypersync_fn: None,
84            parse_initialize_event_hypersync_fn: None,
85            parse_swap_event_hypersync_fn: None,
86            parse_mint_event_hypersync_fn: None,
87            parse_burn_event_hypersync_fn: None,
88            parse_collect_event_hypersync_fn: None,
89            parse_flash_event_hypersync_fn: None,
90            // RPC parsers
91            parse_pool_created_event_rpc_fn: None,
92            parse_initialize_event_rpc_fn: None,
93            parse_swap_event_rpc_fn: None,
94            parse_mint_event_rpc_fn: None,
95            parse_burn_event_rpc_fn: None,
96            parse_collect_event_rpc_fn: None,
97            parse_flash_event_rpc_fn: None,
98        }
99    }
100
101    /// Sets the function used to parse pool creation events from HyperSync logs.
102    pub fn set_pool_created_event_hypersync_parsing(
103        &mut self,
104        parse_fn: fn(HypersyncLog) -> anyhow::Result<PoolCreatedEvent>,
105    ) {
106        self.parse_pool_created_event_hypersync_fn = Some(parse_fn);
107    }
108
109    /// Sets the function used to parse initialize events from HyperSync logs.
110    pub fn set_initialize_event_hypersync_parsing(
111        &mut self,
112        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<InitializeEvent>,
113    ) {
114        self.parse_initialize_event_hypersync_fn = Some(parse_fn);
115    }
116
117    /// Sets the function used to parse swap events from HyperSync logs.
118    pub fn set_swap_event_hypersync_parsing(
119        &mut self,
120        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<SwapEvent>,
121    ) {
122        self.parse_swap_event_hypersync_fn = Some(parse_fn);
123    }
124
125    /// Sets the function used to parse mint events from HyperSync logs.
126    pub fn set_mint_event_hypersync_parsing(
127        &mut self,
128        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<MintEvent>,
129    ) {
130        self.parse_mint_event_hypersync_fn = Some(parse_fn);
131    }
132
133    /// Sets the function used to parse burn events from HyperSync logs.
134    pub fn set_burn_event_hypersync_parsing(
135        &mut self,
136        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<BurnEvent>,
137    ) {
138        self.parse_burn_event_hypersync_fn = Some(parse_fn);
139    }
140
141    /// Sets the function used to parse collect events from HyperSync logs.
142    pub fn set_collect_event_hypersync_parsing(
143        &mut self,
144        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<CollectEvent>,
145    ) {
146        self.parse_collect_event_hypersync_fn = Some(parse_fn);
147    }
148
149    /// Sets the function used to parse flash events from HyperSync logs.
150    pub fn set_flash_event_hypersync_parsing(
151        &mut self,
152        parse_fn: fn(SharedDex, &HypersyncLog) -> anyhow::Result<FlashEvent>,
153    ) {
154        self.parse_flash_event_hypersync_fn = Some(parse_fn);
155    }
156
157    /// Sets the function used to parse pool creation events from RPC logs.
158    pub fn set_pool_created_event_rpc_parsing(
159        &mut self,
160        parse_fn: fn(&RpcLog) -> anyhow::Result<PoolCreatedEvent>,
161    ) {
162        self.parse_pool_created_event_rpc_fn = Some(parse_fn);
163    }
164
165    /// Sets the function used to parse initialize events from RPC logs.
166    pub fn set_initialize_event_rpc_parsing(
167        &mut self,
168        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<InitializeEvent>,
169    ) {
170        self.parse_initialize_event_rpc_fn = Some(parse_fn);
171    }
172
173    /// Sets the function used to parse swap events from RPC logs.
174    pub fn set_swap_event_rpc_parsing(
175        &mut self,
176        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<SwapEvent>,
177    ) {
178        self.parse_swap_event_rpc_fn = Some(parse_fn);
179    }
180
181    /// Sets the function used to parse mint events from RPC logs.
182    pub fn set_mint_event_rpc_parsing(
183        &mut self,
184        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<MintEvent>,
185    ) {
186        self.parse_mint_event_rpc_fn = Some(parse_fn);
187    }
188
189    /// Sets the function used to parse burn events from RPC logs.
190    pub fn set_burn_event_rpc_parsing(
191        &mut self,
192        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<BurnEvent>,
193    ) {
194        self.parse_burn_event_rpc_fn = Some(parse_fn);
195    }
196
197    /// Sets the function used to parse collect events from RPC logs.
198    pub fn set_collect_event_rpc_parsing(
199        &mut self,
200        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<CollectEvent>,
201    ) {
202        self.parse_collect_event_rpc_fn = Some(parse_fn);
203    }
204
205    /// Sets the function used to parse flash events from RPC logs.
206    pub fn set_flash_event_rpc_parsing(
207        &mut self,
208        parse_fn: fn(SharedDex, &RpcLog) -> anyhow::Result<FlashEvent>,
209    ) {
210        self.parse_flash_event_rpc_fn = Some(parse_fn);
211    }
212
213    /// Parses a pool creation event from a HyperSync log.
214    ///
215    /// # Errors
216    ///
217    /// Returns an error if the DEX does not have a HyperSync pool creation event parser defined or if parsing fails.
218    pub fn parse_pool_created_event_hypersync(
219        &self,
220        log: HypersyncLog,
221    ) -> anyhow::Result<PoolCreatedEvent> {
222        if let Some(parse_fn) = &self.parse_pool_created_event_hypersync_fn {
223            parse_fn(log)
224        } else {
225            anyhow::bail!(
226                "HyperSync parsing of pool created event is not defined in this dex: {}:{}",
227                self.dex.chain,
228                self.dex.name,
229            )
230        }
231    }
232
233    /// Parses a swap event from a HyperSync log.
234    ///
235    /// # Errors
236    ///
237    /// Returns an error if the DEX does not have a HyperSync swap event parser defined or if parsing fails.
238    pub fn parse_swap_event_hypersync(&self, log: &HypersyncLog) -> anyhow::Result<SwapEvent> {
239        if let Some(parse_fn) = &self.parse_swap_event_hypersync_fn {
240            parse_fn(self.dex.clone(), log)
241        } else {
242            anyhow::bail!(
243                "HyperSync parsing of swap event is not defined in this dex: {}:{}",
244                self.dex.chain,
245                self.dex.name
246            )
247        }
248    }
249
250    /// Parses a mint event from a HyperSync log.
251    ///
252    /// # Errors
253    ///
254    /// Returns an error if the DEX does not have a HyperSync mint event parser defined or if parsing fails.
255    pub fn parse_mint_event_hypersync(&self, log: &HypersyncLog) -> anyhow::Result<MintEvent> {
256        if let Some(parse_fn) = &self.parse_mint_event_hypersync_fn {
257            parse_fn(self.dex.clone(), log)
258        } else {
259            anyhow::bail!(
260                "HyperSync parsing of mint event is not defined in this dex: {}:{}",
261                self.dex.chain,
262                self.dex.name
263            )
264        }
265    }
266
267    /// Parses a burn event from a HyperSync log.
268    ///
269    /// # Errors
270    ///
271    /// Returns an error if the DEX does not have a HyperSync burn event parser defined or if parsing fails.
272    pub fn parse_burn_event_hypersync(&self, log: &HypersyncLog) -> anyhow::Result<BurnEvent> {
273        if let Some(parse_fn) = &self.parse_burn_event_hypersync_fn {
274            parse_fn(self.dex.clone(), log)
275        } else {
276            anyhow::bail!(
277                "HyperSync parsing of burn event is not defined in this dex: {}:{}",
278                self.dex.chain,
279                self.dex.name
280            )
281        }
282    }
283
284    /// Parses an initialize event from a HyperSync log.
285    ///
286    /// # Errors
287    ///
288    /// Returns an error if the DEX does not have a HyperSync initialize event parser defined or if parsing fails.
289    pub fn parse_initialize_event_hypersync(
290        &self,
291        log: &HypersyncLog,
292    ) -> anyhow::Result<InitializeEvent> {
293        if let Some(parse_fn) = &self.parse_initialize_event_hypersync_fn {
294            parse_fn(self.dex.clone(), log)
295        } else {
296            anyhow::bail!(
297                "HyperSync parsing of initialize event is not defined in this dex: {}:{}",
298                self.dex.chain,
299                self.dex.name
300            )
301        }
302    }
303
304    /// Parses a collect event from a HyperSync log.
305    ///
306    /// # Errors
307    ///
308    /// Returns an error if the DEX does not have a HyperSync collect event parser defined or if parsing fails.
309    pub fn parse_collect_event_hypersync(
310        &self,
311        log: &HypersyncLog,
312    ) -> anyhow::Result<CollectEvent> {
313        if let Some(parse_fn) = &self.parse_collect_event_hypersync_fn {
314            parse_fn(self.dex.clone(), log)
315        } else {
316            anyhow::bail!(
317                "HyperSync parsing of collect event is not defined in this dex: {}:{}",
318                self.dex.chain,
319                self.dex.name
320            )
321        }
322    }
323
324    /// Parses a flash event from a HyperSync log.
325    ///
326    /// # Errors
327    ///
328    /// Returns an error if the DEX does not have a HyperSync flash event parser defined or if parsing fails.
329    pub fn parse_flash_event_hypersync(&self, log: &HypersyncLog) -> anyhow::Result<FlashEvent> {
330        if let Some(parse_fn) = &self.parse_flash_event_hypersync_fn {
331            parse_fn(self.dex.clone(), log)
332        } else {
333            anyhow::bail!(
334                "HyperSync parsing of flash event is not defined in this dex: {}:{}",
335                self.dex.chain,
336                self.dex.name
337            )
338        }
339    }
340
341    /// Parses a pool creation event from an RPC log.
342    ///
343    /// # Errors
344    ///
345    /// Returns an error if the DEX does not have an RPC pool creation event parser defined or if parsing fails.
346    pub fn parse_pool_created_event_rpc(&self, log: &RpcLog) -> anyhow::Result<PoolCreatedEvent> {
347        if let Some(parse_fn) = &self.parse_pool_created_event_rpc_fn {
348            parse_fn(log)
349        } else {
350            anyhow::bail!(
351                "RPC parsing of pool created event is not defined in this dex: {}:{}",
352                self.dex.chain,
353                self.dex.name,
354            )
355        }
356    }
357
358    /// Parses a swap event from an RPC log.
359    ///
360    /// # Errors
361    ///
362    /// Returns an error if the DEX does not have an RPC swap event parser defined or if parsing fails.
363    pub fn parse_swap_event_rpc(&self, log: &RpcLog) -> anyhow::Result<SwapEvent> {
364        if let Some(parse_fn) = &self.parse_swap_event_rpc_fn {
365            parse_fn(self.dex.clone(), log)
366        } else {
367            anyhow::bail!(
368                "RPC parsing of swap event is not defined in this dex: {}:{}",
369                self.dex.chain,
370                self.dex.name
371            )
372        }
373    }
374
375    /// Parses a mint event from an RPC log.
376    ///
377    /// # Errors
378    ///
379    /// Returns an error if the DEX does not have an RPC mint event parser defined or if parsing fails.
380    pub fn parse_mint_event_rpc(&self, log: &RpcLog) -> anyhow::Result<MintEvent> {
381        if let Some(parse_fn) = &self.parse_mint_event_rpc_fn {
382            parse_fn(self.dex.clone(), log)
383        } else {
384            anyhow::bail!(
385                "RPC parsing of mint event is not defined in this dex: {}:{}",
386                self.dex.chain,
387                self.dex.name
388            )
389        }
390    }
391
392    /// Parses a burn event from an RPC log.
393    ///
394    /// # Errors
395    ///
396    /// Returns an error if the DEX does not have an RPC burn event parser defined or if parsing fails.
397    pub fn parse_burn_event_rpc(&self, log: &RpcLog) -> anyhow::Result<BurnEvent> {
398        if let Some(parse_fn) = &self.parse_burn_event_rpc_fn {
399            parse_fn(self.dex.clone(), log)
400        } else {
401            anyhow::bail!(
402                "RPC parsing of burn event is not defined in this dex: {}:{}",
403                self.dex.chain,
404                self.dex.name
405            )
406        }
407    }
408
409    /// Parses an initialize event from an RPC log.
410    ///
411    /// # Errors
412    ///
413    /// Returns an error if the DEX does not have an RPC initialize event parser defined or if parsing fails.
414    pub fn parse_initialize_event_rpc(&self, log: &RpcLog) -> anyhow::Result<InitializeEvent> {
415        if let Some(parse_fn) = &self.parse_initialize_event_rpc_fn {
416            parse_fn(self.dex.clone(), log)
417        } else {
418            anyhow::bail!(
419                "RPC parsing of initialize event is not defined in this dex: {}:{}",
420                self.dex.chain,
421                self.dex.name
422            )
423        }
424    }
425
426    /// Parses a collect event from an RPC log.
427    ///
428    /// # Errors
429    ///
430    /// Returns an error if the DEX does not have an RPC collect event parser defined or if parsing fails.
431    pub fn parse_collect_event_rpc(&self, log: &RpcLog) -> anyhow::Result<CollectEvent> {
432        if let Some(parse_fn) = &self.parse_collect_event_rpc_fn {
433            parse_fn(self.dex.clone(), log)
434        } else {
435            anyhow::bail!(
436                "RPC parsing of collect event is not defined in this dex: {}:{}",
437                self.dex.chain,
438                self.dex.name
439            )
440        }
441    }
442
443    /// Parses a flash event from an RPC log.
444    ///
445    /// # Errors
446    ///
447    /// Returns an error if the DEX does not have an RPC flash event parser defined or if parsing fails.
448    pub fn parse_flash_event_rpc(&self, log: &RpcLog) -> anyhow::Result<FlashEvent> {
449        if let Some(parse_fn) = &self.parse_flash_event_rpc_fn {
450            parse_fn(self.dex.clone(), log)
451        } else {
452            anyhow::bail!(
453                "RPC parsing of flash event is not defined in this dex: {}:{}",
454                self.dex.chain,
455                self.dex.name
456            )
457        }
458    }
459
460    /// Checks if this DEX requires pool initialization events.
461    #[must_use]
462    pub fn needs_initialization(&self) -> bool {
463        self.dex.initialize_event.is_some()
464    }
465}
466
467impl Deref for DexExtended {
468    type Target = Dex;
469
470    fn deref(&self) -> &Self::Target {
471        &self.dex
472    }
473}
nautilus_blockchain/exchanges/extended.rs

nautilus_blockchain/exchanges/
extended.rs
