Skip to main content

nautilus_blockchain/data/
client.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::{collections::VecDeque, sync::Arc, time::Duration};
17
18use alloy::primitives::B256;
19use anyhow::Context;
20use nautilus_common::{
21    clients::DataClient,
22    defi::RequestPoolSnapshot,
23    messages::{
24        DataEvent,
25        defi::{
26            DefiDataCommand, DefiRequestCommand, DefiSubscribeCommand, DefiUnsubscribeCommand,
27            PoolSnapshotResponse, SubscribeBlocks, SubscribePool, SubscribePoolFeeCollects,
28            SubscribePoolFlashEvents, SubscribePoolLiquidityUpdates, SubscribePoolSwaps,
29            UnsubscribeBlocks, UnsubscribePool, UnsubscribePoolFeeCollects,
30            UnsubscribePoolFlashEvents, UnsubscribePoolLiquidityUpdates, UnsubscribePoolSwaps,
31        },
32    },
33};
34use nautilus_live::{
35    SocketControlFactory,
36    task::{TaskGroup, TaskGroupGuard},
37};
38use nautilus_model::{
39    defi::{DefiData, DexType, PoolIdentifier, SharedChain, validation::validate_address},
40    identifiers::{ClientId, Venue},
41};
42use ustr::Ustr;
43
44use crate::{
45    cache::BlockchainCache,
46    config::BlockchainDataClientConfig,
47    data::{
48        block_hash_matches,
49        core::BlockchainDataClientCore,
50        subscription::{BlockFeedBackend, BlockFeedOwner},
51    },
52    exchanges::get_dex_extended,
53    rpc::{
54        BlockchainRpcClient,
55        types::{BlockchainMessage, RpcEventType},
56    },
57};
58
59const MAX_PENDING_POOL_MESSAGES: usize = 10_000;
60
61/// A client for interacting with blockchain data from multiple sources.
62///
63/// The `BlockchainDataClient` serves as a facade that coordinates between different blockchain
64/// data providers, caching mechanisms, and contract interactions. It provides a unified interface
65/// for retrieving and processing blockchain data, particularly focused on DeFi protocols.
66///
67/// This client supports two primary data sources:
68/// 1. Direct RPC connections to blockchain nodes (via WebSocket).
69/// 2. HyperSync API for efficient historical data queries.
70#[derive(Debug)]
71pub struct BlockchainDataClient {
72    /// The client ID used to identify this client with the data engine.
73    pub client_id: ClientId,
74    /// The blockchain being targeted by this client instance.
75    pub chain: SharedChain,
76    /// Configuration parameters for the blockchain data client.
77    pub config: BlockchainDataClientConfig,
78    /// The core client instance that handles blockchain operations.
79    /// Wrapped in Option to allow moving it into the background processing task.
80    pub core_client: Option<BlockchainDataClientCore>,
81    socket_factory: SocketControlFactory,
82    hypersync_rx: Option<tokio::sync::mpsc::UnboundedReceiver<BlockchainMessage>>,
83    hypersync_tx: Option<tokio::sync::mpsc::UnboundedSender<BlockchainMessage>>,
84    command_tx: tokio::sync::mpsc::UnboundedSender<DefiDataCommand>,
85    command_rx: Option<tokio::sync::mpsc::UnboundedReceiver<DefiDataCommand>>,
86    session_tasks: TaskGroup,
87    cancellation_token: tokio_util::sync::CancellationToken,
88}
89
90impl BlockchainDataClient {
91    /// Creates a new [`BlockchainDataClient`] instance for the specified configuration.
92    ///
93    /// # Errors
94    ///
95    /// Returns an error if DEX selections contain duplicates.
96    pub fn new(client_id: ClientId, config: BlockchainDataClientConfig) -> anyhow::Result<Self> {
97        config.validate()?;
98
99        let chain = Arc::clone(&config.chain);
100        let (command_tx, command_rx) = tokio::sync::mpsc::unbounded_channel();
101        let (hypersync_tx, hypersync_rx) = tokio::sync::mpsc::unbounded_channel();
102        let socket_factory = SocketControlFactory::new(client_id, None);
103        let session_tasks = TaskGroup::new();
104        Ok(Self {
105            client_id,
106            chain,
107            core_client: None,
108            socket_factory,
109            config,
110            hypersync_rx: Some(hypersync_rx),
111            hypersync_tx: Some(hypersync_tx),
112            command_tx,
113            command_rx: Some(command_rx),
114            cancellation_token: session_tasks.cancellation_token(),
115            session_tasks,
116        })
117    }
118
119    /// Spawns the main processing task that handles commands and blockchain data.
120    ///
121    /// This method creates a background task that:
122    /// 1. Processes subscription/unsubscription commands from the command channel
123    /// 2. Handles incoming blockchain data from HyperSync
124    /// 3. Processes RPC messages if RPC client is configured
125    /// 4. Routes processed data to subscribers
126    fn spawn_process_task(
127        &mut self,
128    ) -> anyhow::Result<tokio::sync::oneshot::Receiver<anyhow::Result<()>>> {
129        anyhow::ensure!(self.command_rx.is_some(), "Command receiver already taken");
130
131        let cancellation_token = self.cancellation_token.clone();
132
133        let data_tx = nautilus_common::live::runner::get_data_event_sender();
134
135        let hypersync_tx = self.hypersync_tx.clone();
136
137        let mut core_client = BlockchainDataClientCore::new(
138            self.config.clone(),
139            hypersync_tx,
140            Some(data_tx),
141            cancellation_token.clone(),
142        )?;
143        let command_rx = self
144            .command_rx
145            .take()
146            .expect("command receiver was checked");
147        let mut hypersync_rx = self
148            .hypersync_rx
149            .take()
150            .expect("HyperSync receiver is available before startup");
151        self.hypersync_tx = None;
152        core_client.set_socket_control(self.socket_factory.control("blockchain-rpc"));
153
154        let (startup_tx, startup_rx) = tokio::sync::oneshot::channel();
155        let future = async move {
156            log::debug!("Started task 'process'");
157
158            if let Err(e) = core_client.connect().await {
159                let _ = startup_tx.send(Err(e));
160                return;
161            }
162            let _ = startup_tx.send(Ok(()));
163
164            let mut command_rx = command_rx;
165            let mut pending_pool_messages = VecDeque::new();
166
167            loop {
168                tokio::select! {
169                    () = cancellation_token.cancelled() => {
170                        log::debug!("Received cancellation signal in Blockchain data client process task");
171                        core_client.disconnect().await;
172                        break;
173                    }
174                    command = command_rx.recv() => {
175                        if let Some(cmd) = command {
176                            match cmd {
177                                DefiDataCommand::Subscribe(cmd) => {
178                                    let chain = cmd.blockchain();
179                                    if chain != core_client.chain.name {
180                                        log::error!("Incorrect blockchain for subscribe command: {chain}");
181                                        continue;
182                                    }
183
184                                      if let Err(e) = Self::handle_subscribe_command(cmd, &mut core_client).await{
185                                        log::error!("Error processing subscribe command: {e}");
186                                    }
187                                }
188                                DefiDataCommand::Unsubscribe(cmd) => {
189                                    let chain = cmd.blockchain();
190                                    if chain != core_client.chain.name {
191                                        log::error!("Incorrect blockchain for subscribe command: {chain}");
192                                        continue;
193                                    }
194
195                                    if let Err(e) = Self::handle_unsubscribe_command(cmd, &mut core_client).await{
196                                        log::error!("Error processing subscribe command: {e}");
197                                    }
198                                }
199                                DefiDataCommand::Request(cmd) => {
200                                    if let Err(e) = Self::handle_request_command(cmd, &mut core_client).await {
201                                        log::error!("Error processing request command: {e}");
202                                    }
203                                }
204                            }
205                        } else {
206                            log::debug!("Command channel closed");
207                            break;
208                        }
209                    }
210                    data = hypersync_rx.recv() => {
211                        if let Some(msg) = data {
212                            Self::process_live_blockchain_message(
213                                msg,
214                                &mut core_client,
215                                &mut pending_pool_messages,
216                            )
217                            .await;
218                        } else {
219                            log::debug!("HyperSync data channel closed");
220                            break;
221                        }
222                    }
223                    msg = async {
224                        match core_client.rpc_client {
225                            Some(ref mut rpc_client) => rpc_client.next_rpc_message().await,
226                            None => std::future::pending().await,  // Never resolves
227                        }
228                    } => {
229                        // This branch only fires when we actually receive a message
230                        match msg {
231                            Ok(msg) => {
232                                Self::process_live_blockchain_message(
233                                    msg,
234                                    &mut core_client,
235                                    &mut pending_pool_messages,
236                                )
237                                .await;
238                            }
239                            Err(e) => {
240                                log::error!("Error processing RPC message: {e}");
241                            }
242                        }
243                    }
244                }
245            }
246
247            log::debug!("Stopped task 'process'");
248        };
249
250        self.session_tasks
251            .spawn(future)
252            .map_err(|e| anyhow::anyhow!("Failed to register blockchain process task: {e}"))?;
253        Ok(startup_rx)
254    }
255
256    async fn process_live_blockchain_message(
257        msg: BlockchainMessage,
258        core_client: &mut BlockchainDataClientCore,
259        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
260    ) {
261        let is_block = matches!(&msg, BlockchainMessage::Block(_));
262        let Some(msg) =
263            Self::ready_live_blockchain_message(msg, &core_client.cache, pending_pool_messages)
264        else {
265            return;
266        };
267
268        if let Some(data) = Self::data_event_from_blockchain_message(msg, core_client).await {
269            core_client.send_data(data);
270        }
271
272        if is_block {
273            for data in Self::drain_pending_pool_messages(core_client, pending_pool_messages).await
274            {
275                core_client.send_data(data);
276            }
277        }
278    }
279
280    async fn drain_pending_pool_messages(
281        core_client: &mut BlockchainDataClientCore,
282        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
283    ) -> Vec<DataEvent> {
284        let ready_messages = Self::drain_pending_pool_messages_with_cached_metadata(
285            pending_pool_messages,
286            &core_client.cache,
287        );
288        let mut data_events = Vec::with_capacity(ready_messages.len());
289
290        for msg in ready_messages {
291            if let Some(data) = Self::data_event_from_blockchain_message(msg, core_client).await {
292                data_events.push(data);
293            }
294        }
295
296        data_events
297    }
298
299    fn drain_pending_pool_messages_with_cached_metadata(
300        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
301        cache: &BlockchainCache,
302    ) -> Vec<BlockchainMessage> {
303        let pending_count = pending_pool_messages.len();
304        let mut ready_messages = Vec::new();
305
306        for _ in 0..pending_count {
307            let Some(msg) = pending_pool_messages.pop_front() else {
308                break;
309            };
310
311            if Self::pool_event_missing_block_metadata(&msg, cache).is_some() {
312                pending_pool_messages.push_back(msg);
313                continue;
314            }
315
316            ready_messages.push(msg);
317        }
318
319        ready_messages
320    }
321
322    fn queue_pending_pool_message(
323        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
324        msg: BlockchainMessage,
325    ) {
326        if pending_pool_messages.len() >= MAX_PENDING_POOL_MESSAGES
327            && let Some(dropped_msg) = pending_pool_messages.pop_front()
328            && let Some(block_number) = Self::pool_event_block_number(&dropped_msg)
329        {
330            log::warn!(
331                "Dropping oldest live pool event waiting for block {block_number} metadata; pending buffer reached {MAX_PENDING_POOL_MESSAGES} messages"
332            );
333        }
334
335        pending_pool_messages.push_back(msg);
336    }
337
338    fn ready_live_blockchain_message(
339        msg: BlockchainMessage,
340        cache: &BlockchainCache,
341        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
342    ) -> Option<BlockchainMessage> {
343        if let BlockchainMessage::PoolLogRemoved {
344            pool_identifier,
345            transaction_hash,
346            log_index,
347        } = &msg
348        {
349            Self::purge_pending_pool_messages(
350                pending_pool_messages,
351                pool_identifier,
352                transaction_hash,
353                *log_index,
354            );
355            return None;
356        }
357
358        if let Some(block_number) = Self::pool_event_missing_block_metadata(&msg, cache) {
359            log::debug!("Deferring live pool event until block {block_number} metadata is cached");
360            Self::queue_pending_pool_message(pending_pool_messages, msg);
361            None
362        } else {
363            Some(msg)
364        }
365    }
366
367    fn purge_pending_pool_messages(
368        pending_pool_messages: &mut VecDeque<BlockchainMessage>,
369        pool_identifier: &PoolIdentifier,
370        transaction_hash: &str,
371        log_index: u32,
372    ) {
373        pending_pool_messages.retain(|msg| {
374            let is_match = Self::pool_event_identity(msg).is_some_and(
375                |(pending_pool_identifier, pending_transaction_hash, pending_log_index)| {
376                    pending_pool_identifier == pool_identifier
377                        && pending_transaction_hash.eq_ignore_ascii_case(transaction_hash)
378                        && pending_log_index == log_index
379                },
380            );
381
382            !is_match
383        });
384    }
385
386    fn pool_event_identity(msg: &BlockchainMessage) -> Option<(&PoolIdentifier, &str, u32)> {
387        match msg {
388            BlockchainMessage::SwapEvent(event) => Some((
389                &event.pool_identifier,
390                event.transaction_hash.as_str(),
391                event.log_index,
392            )),
393            BlockchainMessage::MintEvent(event) => Some((
394                &event.pool_identifier,
395                event.transaction_hash.as_str(),
396                event.log_index,
397            )),
398            BlockchainMessage::BurnEvent(event) => Some((
399                &event.pool_identifier,
400                event.transaction_hash.as_str(),
401                event.log_index,
402            )),
403            BlockchainMessage::CollectEvent(event) => Some((
404                &event.pool_identifier,
405                event.transaction_hash.as_str(),
406                event.log_index,
407            )),
408            BlockchainMessage::FlashEvent(event) => Some((
409                &event.pool_identifier,
410                event.transaction_hash.as_str(),
411                event.log_index,
412            )),
413            BlockchainMessage::FeeProtocolUpdateEvent(event) => Some((
414                &event.pool_identifier,
415                event.transaction_hash.as_str(),
416                event.log_index,
417            )),
418            BlockchainMessage::FeeProtocolCollectEvent(event) => Some((
419                &event.pool_identifier,
420                event.transaction_hash.as_str(),
421                event.log_index,
422            )),
423            BlockchainMessage::Block(_) | BlockchainMessage::PoolLogRemoved { .. } => None,
424        }
425    }
426
427    fn pool_event_missing_block_metadata(
428        msg: &BlockchainMessage,
429        cache: &BlockchainCache,
430    ) -> Option<u64> {
431        let block_number = Self::pool_event_block_number(msg)?;
432        let observed_hash = Self::pool_event_block_hash(msg);
433        let hash_matches = cache
434            .get_block_hash(block_number)
435            .is_some_and(|cached| block_hash_matches(observed_hash, cached));
436        (cache.get_block_timestamp(block_number).is_none() || !hash_matches).then_some(block_number)
437    }
438
439    fn pool_event_block_number(msg: &BlockchainMessage) -> Option<u64> {
440        match msg {
441            BlockchainMessage::SwapEvent(event) => Some(event.block_number),
442            BlockchainMessage::MintEvent(event) => Some(event.block_number),
443            BlockchainMessage::BurnEvent(event) => Some(event.block_number),
444            BlockchainMessage::CollectEvent(event) => Some(event.block_number),
445            BlockchainMessage::FlashEvent(event) => Some(event.block_number),
446            BlockchainMessage::FeeProtocolUpdateEvent(event) => Some(event.block_number),
447            BlockchainMessage::FeeProtocolCollectEvent(event) => Some(event.block_number),
448            BlockchainMessage::Block(_) | BlockchainMessage::PoolLogRemoved { .. } => None,
449        }
450    }
451
452    fn pool_event_block_hash(msg: &BlockchainMessage) -> Option<B256> {
453        match msg {
454            BlockchainMessage::SwapEvent(event) => event.block_hash,
455            BlockchainMessage::MintEvent(event) => event.block_hash,
456            BlockchainMessage::BurnEvent(event) => event.block_hash,
457            BlockchainMessage::CollectEvent(event) => event.block_hash,
458            BlockchainMessage::FlashEvent(event) => event.block_hash,
459            BlockchainMessage::FeeProtocolUpdateEvent(event) => event.block_hash,
460            BlockchainMessage::FeeProtocolCollectEvent(event) => event.block_hash,
461            BlockchainMessage::Block(_) | BlockchainMessage::PoolLogRemoved { .. } => None,
462        }
463    }
464
465    async fn data_event_from_blockchain_message(
466        msg: BlockchainMessage,
467        core_client: &mut BlockchainDataClientCore,
468    ) -> Option<DataEvent> {
469        match msg {
470            BlockchainMessage::Block(block) => {
471                if let Err(e) = core_client.cache.add_block(block.clone()).await {
472                    log::error!("Failed to cache block {}: {e}", block.number);
473                }
474
475                Some(DataEvent::DeFi(DefiData::Block(block)))
476            }
477            BlockchainMessage::PoolLogRemoved { .. } => None,
478            BlockchainMessage::SwapEvent(swap_event) => {
479                match core_client.get_pool(&swap_event.pool_identifier) {
480                    Ok(pool) => match core_client.process_pool_swap_event(&swap_event, pool) {
481                        Ok(swap) => Some(DataEvent::DeFi(DefiData::PoolSwap(swap))),
482                        Err(e) => {
483                            log::error!("Error processing pool swap event: {e}");
484                            None
485                        }
486                    },
487                    Err(e) => {
488                        log::error!(
489                            "Failed to get pool {} with error {:?}",
490                            swap_event.pool_identifier,
491                            e
492                        );
493                        None
494                    }
495                }
496            }
497            BlockchainMessage::BurnEvent(burn_event) => {
498                match core_client.get_pool(&burn_event.pool_identifier) {
499                    Ok(pool) => {
500                        let dex_extended = get_dex_extended(core_client.chain.name, &pool.dex.name)
501                            .expect("Failed to get dex extended");
502
503                        match core_client.process_pool_burn_event(&burn_event, pool, dex_extended) {
504                            Ok(update) => {
505                                Some(DataEvent::DeFi(DefiData::PoolLiquidityUpdate(update)))
506                            }
507                            Err(e) => {
508                                log::error!("Error processing pool burn event: {e}");
509                                None
510                            }
511                        }
512                    }
513                    Err(e) => {
514                        log::error!(
515                            "Failed to get pool {} with error {:?}",
516                            burn_event.pool_identifier,
517                            e
518                        );
519                        None
520                    }
521                }
522            }
523            BlockchainMessage::MintEvent(mint_event) => {
524                match core_client.get_pool(&mint_event.pool_identifier) {
525                    Ok(pool) => {
526                        let dex_extended = get_dex_extended(core_client.chain.name, &pool.dex.name)
527                            .expect("Failed to get dex extended");
528
529                        match core_client.process_pool_mint_event(&mint_event, pool, dex_extended) {
530                            Ok(update) => {
531                                Some(DataEvent::DeFi(DefiData::PoolLiquidityUpdate(update)))
532                            }
533                            Err(e) => {
534                                log::error!("Error processing pool mint event: {e}");
535                                None
536                            }
537                        }
538                    }
539                    Err(e) => {
540                        log::error!(
541                            "Failed to get pool {} with error {:?}",
542                            mint_event.pool_identifier,
543                            e
544                        );
545                        None
546                    }
547                }
548            }
549            BlockchainMessage::CollectEvent(collect_event) => {
550                match core_client.get_pool(&collect_event.pool_identifier) {
551                    Ok(pool) => {
552                        let dex_extended = get_dex_extended(core_client.chain.name, &pool.dex.name)
553                            .expect("Failed to get dex extended");
554
555                        match core_client.process_pool_collect_event(
556                            &collect_event,
557                            pool,
558                            dex_extended,
559                        ) {
560                            Ok(update) => Some(DataEvent::DeFi(DefiData::PoolFeeCollect(update))),
561                            Err(e) => {
562                                log::error!("Error processing pool collect event: {e}");
563                                None
564                            }
565                        }
566                    }
567                    Err(e) => {
568                        log::error!(
569                            "Failed to get pool {} with error {:?}",
570                            collect_event.pool_identifier,
571                            e
572                        );
573                        None
574                    }
575                }
576            }
577            BlockchainMessage::FlashEvent(flash_event) => {
578                match core_client.get_pool(&flash_event.pool_identifier) {
579                    Ok(pool) => match core_client.process_pool_flash_event(&flash_event, pool) {
580                        Ok(flash) => Some(DataEvent::DeFi(DefiData::PoolFlash(flash))),
581                        Err(e) => {
582                            log::error!("Error processing pool flash event: {e}");
583                            None
584                        }
585                    },
586                    Err(e) => {
587                        log::error!(
588                            "Failed to get pool {} with error {:?}",
589                            flash_event.pool_identifier,
590                            e
591                        );
592                        None
593                    }
594                }
595            }
596            BlockchainMessage::FeeProtocolUpdateEvent(update_event) => {
597                match core_client.get_pool(&update_event.pool_identifier) {
598                    Ok(pool) => match core_client
599                        .process_pool_fee_protocol_update_event(&update_event, pool)
600                    {
601                        Ok(update) => {
602                            Some(DataEvent::DeFi(DefiData::PoolFeeProtocolUpdate(update)))
603                        }
604                        Err(e) => {
605                            log::error!("Error processing pool fee-protocol update event: {e}");
606                            None
607                        }
608                    },
609                    Err(e) => {
610                        log::error!(
611                            "Failed to get pool {} with error {:?}",
612                            update_event.pool_identifier,
613                            e
614                        );
615                        None
616                    }
617                }
618            }
619            BlockchainMessage::FeeProtocolCollectEvent(collect_event) => {
620                match core_client.get_pool(&collect_event.pool_identifier) {
621                    Ok(pool) => match core_client
622                        .process_pool_fee_protocol_collect_event(&collect_event, pool)
623                    {
624                        Ok(collect) => {
625                            Some(DataEvent::DeFi(DefiData::PoolFeeProtocolCollect(collect)))
626                        }
627                        Err(e) => {
628                            log::error!("Error processing pool fee-protocol collect event: {e}");
629                            None
630                        }
631                    },
632                    Err(e) => {
633                        log::error!(
634                            "Failed to get pool {} with error {:?}",
635                            collect_event.pool_identifier,
636                            e
637                        );
638                        None
639                    }
640                }
641            }
642        }
643    }
644
645    /// Processes DeFi subscription commands to start receiving specific blockchain data.
646    async fn handle_subscribe_command(
647        command: DefiSubscribeCommand,
648        core_client: &mut BlockchainDataClientCore,
649    ) -> anyhow::Result<()> {
650        match command {
651            DefiSubscribeCommand::Blocks(_cmd) => {
652                log::debug!("Processing subscribe blocks command");
653
654                Self::subscribe_block_feed(core_client, BlockFeedOwner::Explicit).await?;
655
656                Ok(())
657            }
658            DefiSubscribeCommand::Pool(cmd) => {
659                log::debug!(
660                    "Processing subscribe pool command for {}",
661                    cmd.instrument_id
662                );
663
664                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
665                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
666                        .map_err(|e| {
667                            anyhow::anyhow!(
668                                "Invalid pool address '{}' failed with error: {:?}",
669                                cmd.instrument_id,
670                                e
671                            )
672                        })?;
673
674                    core_client
675                        .subscription_manager
676                        .subscribe_pool(dex, pool_address);
677                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
678                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
679
680                    log::debug!(
681                        "Subscribed to all pool events for {} at address {}",
682                        cmd.instrument_id,
683                        pool_address
684                    );
685                } else {
686                    anyhow::bail!(
687                        "Invalid venue {}, expected Blockchain DEX format",
688                        cmd.instrument_id.venue
689                    )
690                }
691
692                Ok(())
693            }
694            DefiSubscribeCommand::PoolSwaps(cmd) => {
695                log::debug!(
696                    "Processing subscribe pool swaps command for {}",
697                    cmd.instrument_id
698                );
699
700                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
701                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
702                        .map_err(|e| {
703                            anyhow::anyhow!(
704                                "Invalid pool swap address '{}' failed with error: {:?}",
705                                cmd.instrument_id,
706                                e
707                            )
708                        })?;
709                    core_client
710                        .subscription_manager
711                        .subscribe_swaps(dex, pool_address);
712                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
713                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
714                } else {
715                    anyhow::bail!(
716                        "Invalid venue {}, expected Blockchain DEX format",
717                        cmd.instrument_id.venue
718                    )
719                }
720
721                Ok(())
722            }
723            DefiSubscribeCommand::PoolLiquidityUpdates(cmd) => {
724                log::debug!(
725                    "Processing subscribe pool liquidity updates command for address: {}",
726                    cmd.instrument_id
727                );
728
729                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
730                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
731                        .map_err(|_| {
732                            anyhow::anyhow!("Invalid pool swap address: {}", cmd.instrument_id)
733                        })?;
734                    core_client
735                        .subscription_manager
736                        .subscribe_burns(dex, pool_address);
737                    core_client
738                        .subscription_manager
739                        .subscribe_mints(dex, pool_address);
740                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
741                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
742                } else {
743                    anyhow::bail!(
744                        "Invalid venue {}, expected Blockchain DEX format",
745                        cmd.instrument_id.venue
746                    )
747                }
748
749                Ok(())
750            }
751            DefiSubscribeCommand::PoolFeeCollects(cmd) => {
752                log::debug!(
753                    "Processing subscribe pool fee collects command for address: {}",
754                    cmd.instrument_id
755                );
756
757                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
758                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
759                        .map_err(|_| {
760                            anyhow::anyhow!(
761                                "Invalid pool fee collect address: {}",
762                                cmd.instrument_id
763                            )
764                        })?;
765                    core_client
766                        .subscription_manager
767                        .subscribe_collects(dex, pool_address);
768                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
769                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
770                } else {
771                    anyhow::bail!(
772                        "Invalid venue {}, expected Blockchain DEX format",
773                        cmd.instrument_id.venue
774                    )
775                }
776
777                Ok(())
778            }
779            DefiSubscribeCommand::PoolFlashEvents(cmd) => {
780                log::debug!(
781                    "Processing subscribe pool flash command for address: {}",
782                    cmd.instrument_id
783                );
784
785                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
786                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
787                        .map_err(|_| {
788                            anyhow::anyhow!(
789                                "Invalid pool flash subscribe address: {}",
790                                cmd.instrument_id
791                            )
792                        })?;
793                    core_client
794                        .subscription_manager
795                        .subscribe_flashes(dex, pool_address);
796                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
797                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
798                } else {
799                    anyhow::bail!(
800                        "Invalid venue {}, expected Blockchain DEX format",
801                        cmd.instrument_id.venue
802                    )
803                }
804
805                Ok(())
806            }
807        }
808    }
809
810    /// Processes DeFi unsubscription commands to stop receiving specific blockchain data.
811    async fn handle_unsubscribe_command(
812        command: DefiUnsubscribeCommand,
813        core_client: &mut BlockchainDataClientCore,
814    ) -> anyhow::Result<()> {
815        match command {
816            DefiUnsubscribeCommand::Blocks(_cmd) => {
817                log::debug!("Processing unsubscribe blocks command");
818
819                Self::unsubscribe_block_feed(core_client, BlockFeedOwner::Explicit).await?;
820
821                Ok(())
822            }
823            DefiUnsubscribeCommand::Pool(cmd) => {
824                log::debug!(
825                    "Processing unsubscribe pool command for {}",
826                    cmd.instrument_id
827                );
828
829                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
830                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
831                        .map_err(|_| {
832                            anyhow::anyhow!("Invalid pool address: {}", cmd.instrument_id)
833                        })?;
834
835                    core_client
836                        .subscription_manager
837                        .unsubscribe_pool(dex, pool_address);
838                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
839                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
840
841                    log::debug!(
842                        "Unsubscribed from all pool events for {} at address {}",
843                        cmd.instrument_id,
844                        pool_address
845                    );
846                } else {
847                    anyhow::bail!(
848                        "Invalid venue {}, expected Blockchain DEX format",
849                        cmd.instrument_id.venue
850                    )
851                }
852
853                Ok(())
854            }
855            DefiUnsubscribeCommand::PoolSwaps(cmd) => {
856                log::debug!("Processing unsubscribe pool swaps command");
857
858                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
859                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
860                        .map_err(|_| {
861                            anyhow::anyhow!("Invalid pool swap address: {}", cmd.instrument_id)
862                        })?;
863                    core_client
864                        .subscription_manager
865                        .unsubscribe_swaps(dex, pool_address);
866                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
867                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
868                } else {
869                    anyhow::bail!(
870                        "Invalid venue {}, expected Blockchain DEX format",
871                        cmd.instrument_id.venue
872                    )
873                }
874
875                Ok(())
876            }
877            DefiUnsubscribeCommand::PoolLiquidityUpdates(cmd) => {
878                log::debug!(
879                    "Processing unsubscribe pool liquidity updates command for {}",
880                    cmd.instrument_id
881                );
882
883                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
884                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
885                        .map_err(|_| {
886                            anyhow::anyhow!("Invalid pool swap address: {}", cmd.instrument_id)
887                        })?;
888                    core_client
889                        .subscription_manager
890                        .unsubscribe_burns(dex, pool_address);
891                    core_client
892                        .subscription_manager
893                        .unsubscribe_mints(dex, pool_address);
894                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
895                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
896                } else {
897                    anyhow::bail!(
898                        "Invalid venue {}, expected Blockchain DEX format",
899                        cmd.instrument_id.venue
900                    )
901                }
902
903                Ok(())
904            }
905            DefiUnsubscribeCommand::PoolFeeCollects(cmd) => {
906                log::debug!(
907                    "Processing unsubscribe pool fee collects command for {}",
908                    cmd.instrument_id
909                );
910
911                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
912                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
913                        .map_err(|_| {
914                            anyhow::anyhow!(
915                                "Invalid pool fee collect address: {}",
916                                cmd.instrument_id
917                            )
918                        })?;
919                    core_client
920                        .subscription_manager
921                        .unsubscribe_collects(dex, pool_address);
922                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
923                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
924                } else {
925                    anyhow::bail!(
926                        "Invalid venue {}, expected Blockchain DEX format",
927                        cmd.instrument_id.venue
928                    )
929                }
930
931                Ok(())
932            }
933            DefiUnsubscribeCommand::PoolFlashEvents(cmd) => {
934                log::debug!(
935                    "Processing unsubscribe pool flash command for {}",
936                    cmd.instrument_id
937                );
938
939                if let Ok((_, dex)) = cmd.instrument_id.venue.parse_dex() {
940                    let pool_address = validate_address(cmd.instrument_id.symbol.as_str())
941                        .map_err(|_| {
942                            anyhow::anyhow!("Invalid pool flash address: {}", cmd.instrument_id)
943                        })?;
944                    core_client
945                        .subscription_manager
946                        .unsubscribe_flashes(dex, pool_address);
947                    Self::update_rpc_pool_event_subscriptions(core_client, dex).await?;
948                    Self::update_hypersync_pool_event_stream(core_client, dex).await?;
949                } else {
950                    anyhow::bail!(
951                        "Invalid venue {}, expected Blockchain DEX format",
952                        cmd.instrument_id.venue
953                    )
954                }
955
956                Ok(())
957            }
958        }
959    }
960
961    async fn update_rpc_pool_event_subscriptions(
962        core_client: &mut BlockchainDataClientCore,
963        dex: DexType,
964    ) -> anyhow::Result<()> {
965        let updates = vec![
966            (
967                RpcEventType::PoolSwap(dex),
968                core_client
969                    .subscription_manager
970                    .get_subscribed_pool_swap_addresses(&dex),
971                core_client
972                    .subscription_manager
973                    .get_dex_pool_swap_event_signature(&dex),
974            ),
975            (
976                RpcEventType::PoolMint(dex),
977                core_client
978                    .subscription_manager
979                    .get_subscribed_pool_mint_addresses(&dex),
980                core_client
981                    .subscription_manager
982                    .get_dex_pool_mint_event_signature(&dex),
983            ),
984            (
985                RpcEventType::PoolBurn(dex),
986                core_client
987                    .subscription_manager
988                    .get_subscribed_pool_burn_addresses(&dex),
989                core_client
990                    .subscription_manager
991                    .get_dex_pool_burn_event_signature(&dex),
992            ),
993            (
994                RpcEventType::PoolCollect(dex),
995                core_client
996                    .subscription_manager
997                    .get_subscribed_pool_collect_addresses(&dex),
998                core_client
999                    .subscription_manager
1000                    .get_dex_pool_collect_event_signature(&dex),
1001            ),
1002            (
1003                RpcEventType::PoolFlash(dex),
1004                core_client
1005                    .subscription_manager
1006                    .get_subscribed_pool_flash_addresses(&dex),
1007                core_client
1008                    .subscription_manager
1009                    .get_dex_pool_flash_event_signature(&dex),
1010            ),
1011            (
1012                RpcEventType::PoolFeeProtocolUpdate(dex),
1013                core_client
1014                    .subscription_manager
1015                    .get_subscribed_pool_fee_protocol_update_addresses(&dex),
1016                core_client
1017                    .subscription_manager
1018                    .get_dex_pool_fee_protocol_update_event_signature(&dex),
1019            ),
1020            (
1021                RpcEventType::PoolFeeProtocolCollect(dex),
1022                core_client
1023                    .subscription_manager
1024                    .get_subscribed_pool_fee_protocol_collect_addresses(&dex),
1025                core_client
1026                    .subscription_manager
1027                    .get_dex_pool_fee_protocol_collect_event_signature(&dex),
1028            ),
1029        ];
1030
1031        let has_pool_event_subscriptions = Self::has_active_pool_event_subscriptions(core_client);
1032
1033        if core_client.rpc_client.is_none() {
1034            return Ok(());
1035        }
1036
1037        if has_pool_event_subscriptions {
1038            Self::subscribe_block_feed(core_client, BlockFeedOwner::PoolEvents).await?;
1039        }
1040
1041        if let Some(ref mut rpc) = core_client.rpc_client {
1042            for (event_type, addresses, event_signature) in updates {
1043                if let Some(event_signature) = event_signature {
1044                    rpc.subscribe_pool_events(event_type, &addresses, event_signature)
1045                        .await?;
1046                }
1047            }
1048        }
1049
1050        if !has_pool_event_subscriptions {
1051            Self::unsubscribe_block_feed(core_client, BlockFeedOwner::PoolEvents).await?;
1052        }
1053
1054        Ok(())
1055    }
1056
1057    async fn update_hypersync_pool_event_stream(
1058        core_client: &mut BlockchainDataClientCore,
1059        dex: DexType,
1060    ) -> anyhow::Result<()> {
1061        if core_client.rpc_client.is_some() {
1062            return Ok(());
1063        }
1064
1065        let addresses = core_client
1066            .subscription_manager
1067            .get_subscribed_dex_contract_addresses(&dex);
1068        let event_signatures = core_client
1069            .subscription_manager
1070            .get_active_subscribed_dex_event_signatures(&dex);
1071        let has_pool_event_subscriptions = Self::has_active_pool_event_subscriptions(core_client);
1072
1073        if has_pool_event_subscriptions {
1074            Self::subscribe_block_feed(core_client, BlockFeedOwner::PoolEvents).await?;
1075        }
1076
1077        core_client
1078            .hypersync_client
1079            .update_dex_event_stream(dex, addresses, event_signatures)
1080            .await;
1081
1082        if !has_pool_event_subscriptions {
1083            Self::unsubscribe_block_feed(core_client, BlockFeedOwner::PoolEvents).await?;
1084        }
1085
1086        Ok(())
1087    }
1088
1089    fn has_active_pool_event_subscriptions(core_client: &BlockchainDataClientCore) -> bool {
1090        core_client
1091            .subscription_manager
1092            .has_pool_event_subscriptions()
1093    }
1094
1095    async fn subscribe_block_feed(
1096        core_client: &mut BlockchainDataClientCore,
1097        owner: BlockFeedOwner,
1098    ) -> anyhow::Result<()> {
1099        let preferred_backend = if core_client.rpc_client.is_some() {
1100            BlockFeedBackend::Rpc
1101        } else {
1102            BlockFeedBackend::HyperSync
1103        };
1104        let Some(backend) = core_client
1105            .subscription_manager
1106            .add_block_demand(owner, preferred_backend)
1107        else {
1108            return Ok(());
1109        };
1110
1111        let started_backend = match backend {
1112            BlockFeedBackend::Rpc => {
1113                let Some(rpc) = core_client.rpc_client.as_mut() else {
1114                    anyhow::bail!("RPC block feed selected without an RPC client")
1115                };
1116
1117                match rpc.subscribe_blocks().await {
1118                    Ok(()) => {
1119                        log::debug!("Successfully subscribed to blocks via RPC");
1120                        BlockFeedBackend::Rpc
1121                    }
1122                    Err(e) if owner == BlockFeedOwner::Explicit => {
1123                        log::warn!(
1124                            "RPC blocks subscription failed: {e}, falling back to HyperSync"
1125                        );
1126                        core_client.hypersync_client.subscribe_blocks();
1127                        tokio::task::yield_now().await;
1128                        BlockFeedBackend::HyperSync
1129                    }
1130                    Err(e) => return Err(e.into()),
1131                }
1132            }
1133            BlockFeedBackend::HyperSync => {
1134                log::debug!("Subscribing to blocks via HyperSync");
1135                core_client.hypersync_client.subscribe_blocks();
1136                tokio::task::yield_now().await;
1137                BlockFeedBackend::HyperSync
1138            }
1139        };
1140
1141        core_client
1142            .subscription_manager
1143            .block_feed_started(started_backend);
1144        Ok(())
1145    }
1146
1147    async fn unsubscribe_block_feed(
1148        core_client: &mut BlockchainDataClientCore,
1149        owner: BlockFeedOwner,
1150    ) -> anyhow::Result<()> {
1151        let Some(backend) = core_client.subscription_manager.remove_block_demand(owner) else {
1152            log::debug!("Keeping block subscription active while another owner remains");
1153            return Ok(());
1154        };
1155
1156        match backend {
1157            BlockFeedBackend::Rpc => {
1158                let Some(rpc) = core_client.rpc_client.as_mut() else {
1159                    anyhow::bail!("RPC block feed active without an RPC client")
1160                };
1161                rpc.unsubscribe_blocks().await?;
1162                log::debug!("Unsubscribed from blocks via RPC");
1163            }
1164            BlockFeedBackend::HyperSync => {
1165                core_client.hypersync_client.unsubscribe_blocks().await;
1166                log::debug!("Unsubscribed from blocks via HyperSync");
1167            }
1168        }
1169
1170        core_client.subscription_manager.block_feed_stopped(backend);
1171        Ok(())
1172    }
1173
1174    /// Processes DeFi request commands to fetch specific blockchain data.
1175    async fn handle_request_command(
1176        command: DefiRequestCommand,
1177        core_client: &mut BlockchainDataClientCore,
1178    ) -> anyhow::Result<()> {
1179        match command {
1180            DefiRequestCommand::PoolSnapshot(cmd) => {
1181                log::debug!("Processing pool snapshot request for {}", cmd.instrument_id);
1182
1183                let pool_address =
1184                    validate_address(cmd.instrument_id.symbol.as_str()).map_err(|e| {
1185                        anyhow::anyhow!(
1186                            "Invalid pool address '{}' failed with error: {:?}",
1187                            cmd.instrument_id,
1188                            e
1189                        )
1190                    })?;
1191
1192                let pool_identifier =
1193                    PoolIdentifier::Address(Ustr::from(&pool_address.to_string()));
1194
1195                match core_client.get_pool(&pool_identifier) {
1196                    Ok(pool) => {
1197                        let pool = Arc::clone(pool);
1198                        log::debug!("Found pool for snapshot request: {}", cmd.instrument_id);
1199
1200                        // Send the pool definition
1201                        let pool_data = DataEvent::DeFi(DefiData::Pool(pool.as_ref().clone()));
1202                        core_client.send_data(pool_data);
1203
1204                        match core_client
1205                            .bootstrap_latest_pool_profiler(&pool, None)
1206                            .await
1207                        {
1208                            Ok((profiler, already_valid)) => match profiler.extract_snapshot() {
1209                                Ok(snapshot) => {
1210                                    log::debug!(
1211                                        "Saving pool snapshot with {} positions and {} ticks to database...",
1212                                        snapshot.positions.len(),
1213                                        snapshot.ticks.len()
1214                                    );
1215                                    core_client
1216                                        .cache
1217                                        .add_pool_snapshot(
1218                                            &pool.dex.name,
1219                                            &pool.pool_identifier,
1220                                            &snapshot,
1221                                        )
1222                                        .await?;
1223
1224                                    // If the snapshot is usable, send it back to the data engine.
1225                                    if core_client
1226                                        .check_snapshot_validity(&profiler, already_valid)
1227                                        .await?
1228                                        .is_usable()
1229                                    {
1230                                        let response =
1231                                            PoolSnapshotResponse::new(cmd.request_id, snapshot);
1232                                        core_client
1233                                            .send_data(DataEvent::PoolSnapshotResponse(response));
1234                                    }
1235                                }
1236                                Err(e) => log::error!(
1237                                    "Failed to extract snapshot for {}: {e}",
1238                                    cmd.instrument_id
1239                                ),
1240                            },
1241                            Err(e) => log::error!(
1242                                "Failed to bootstrap pool profiler for {} and extract snapshot with error {e}",
1243                                cmd.instrument_id
1244                            ),
1245                        }
1246                    }
1247                    Err(e) => {
1248                        log::warn!("Pool {} not found in cache: {e}", cmd.instrument_id);
1249                    }
1250                }
1251
1252                Ok(())
1253            }
1254        }
1255    }
1256
1257    /// Waits for the background processing task to complete.
1258    ///
1259    /// This method blocks until the spawned process task finishes execution,
1260    /// which typically happens after a shutdown signal is sent.
1261    ///
1262    /// # Errors
1263    ///
1264    /// Returns an error if bounded task shutdown fails.
1265    pub async fn await_process_task_close(&self) -> anyhow::Result<()> {
1266        self.session_tasks
1267            .finish_shutdown(Duration::from_secs(2), Duration::from_secs(2))
1268            .await
1269            .map_err(|e| anyhow::anyhow!("Blockchain process task shutdown failed: {e}"))?;
1270        Ok(())
1271    }
1272
1273    async fn prepare_task_group(&mut self) -> anyhow::Result<()> {
1274        if !self.session_tasks.is_open() {
1275            self.session_tasks.begin_shutdown();
1276            self.await_process_task_close().await?;
1277            self.reset_channels();
1278            self.session_tasks
1279                .start_generation()
1280                .map_err(|e| anyhow::anyhow!("Failed to start blockchain task generation: {e}"))?;
1281            self.cancellation_token = self.session_tasks.cancellation_token();
1282        }
1283        Ok(())
1284    }
1285
1286    fn reset_channels(&mut self) {
1287        let (hypersync_tx, hypersync_rx) = tokio::sync::mpsc::unbounded_channel();
1288        self.hypersync_tx = Some(hypersync_tx);
1289        self.hypersync_rx = Some(hypersync_rx);
1290        let (command_tx, command_rx) = tokio::sync::mpsc::unbounded_channel();
1291        self.command_tx = command_tx;
1292        self.command_rx = Some(command_rx);
1293    }
1294}
1295
1296#[async_trait::async_trait(?Send)]
1297impl DataClient for BlockchainDataClient {
1298    fn client_id(&self) -> ClientId {
1299        self.client_id
1300    }
1301
1302    fn venue(&self) -> Option<Venue> {
1303        // Blockchain data clients don't map to a single venue since they can provide
1304        // data for multiple DEXs across the blockchain
1305        None
1306    }
1307
1308    fn start(&mut self) -> anyhow::Result<()> {
1309        log::info!(
1310            "Starting blockchain data client: chain_name={}, dex_ids={:?}, use_hypersync_for_live_data={}, proxy_url={:?}",
1311            self.chain.name,
1312            self.config.dex_ids,
1313            self.config.use_hypersync_for_live_data,
1314            self.config.proxy_url
1315        );
1316        Ok(())
1317    }
1318
1319    fn stop(&mut self) -> anyhow::Result<()> {
1320        log::info!(
1321            "Stopping blockchain data client for '{chain_name}'",
1322            chain_name = self.chain.name
1323        );
1324        self.session_tasks.begin_shutdown();
1325        Ok(())
1326    }
1327
1328    fn reset(&mut self) -> anyhow::Result<()> {
1329        log::info!(
1330            "Resetting blockchain data client for '{chain_name}'",
1331            chain_name = self.chain.name
1332        );
1333        self.session_tasks.begin_shutdown();
1334        Ok(())
1335    }
1336
1337    fn dispose(&mut self) -> anyhow::Result<()> {
1338        log::info!(
1339            "Disposing blockchain data client for '{chain_name}'",
1340            chain_name = self.chain.name
1341        );
1342        self.session_tasks.begin_shutdown();
1343        Ok(())
1344    }
1345
1346    async fn connect(&mut self) -> anyhow::Result<()> {
1347        self.config.validate()?;
1348
1349        if self.session_tasks.is_open() && !self.session_tasks.is_empty() {
1350            return Ok(());
1351        }
1352
1353        log::info!(
1354            "Connecting blockchain data client for '{}'",
1355            self.chain.name
1356        );
1357
1358        self.prepare_task_group().await?;
1359        let setup_guard = TaskGroupGuard::new(&[&self.session_tasks], || {});
1360        let startup = self.spawn_process_task()?;
1361        if let Err(e) = startup
1362            .await
1363            .context("Blockchain process task stopped before startup")?
1364        {
1365            self.session_tasks.begin_shutdown();
1366            let teardown_result = self.await_process_task_close().await;
1367            self.reset_channels();
1368
1369            if let Err(teardown_error) = teardown_result {
1370                return Err(e.context(format!(
1371                    "Blockchain data startup teardown failed: {teardown_error}"
1372                )));
1373            }
1374            return Err(e);
1375        }
1376
1377        setup_guard.disarm();
1378        Ok(())
1379    }
1380
1381    async fn disconnect(&mut self) -> anyhow::Result<()> {
1382        log::info!(
1383            "Disconnecting blockchain data client for '{}'",
1384            self.chain.name
1385        );
1386
1387        self.session_tasks.begin_shutdown();
1388        let tasks_result = self.await_process_task_close().await;
1389        self.reset_channels();
1390
1391        tasks_result
1392    }
1393
1394    fn is_connected(&self) -> bool {
1395        self.session_tasks.is_open()
1396            && !self.session_tasks.is_empty()
1397            && !self.session_tasks.all_finished()
1398    }
1399
1400    fn is_disconnected(&self) -> bool {
1401        !self.is_connected()
1402    }
1403
1404    fn subscribe_blocks(&mut self, cmd: SubscribeBlocks) -> anyhow::Result<()> {
1405        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::Blocks(cmd));
1406        self.command_tx.send(command)?;
1407        Ok(())
1408    }
1409
1410    fn subscribe_pool(&mut self, cmd: SubscribePool) -> anyhow::Result<()> {
1411        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::Pool(cmd));
1412        self.command_tx.send(command)?;
1413        Ok(())
1414    }
1415
1416    fn subscribe_pool_swaps(&mut self, cmd: SubscribePoolSwaps) -> anyhow::Result<()> {
1417        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::PoolSwaps(cmd));
1418        self.command_tx.send(command)?;
1419        Ok(())
1420    }
1421
1422    fn subscribe_pool_liquidity_updates(
1423        &mut self,
1424        cmd: SubscribePoolLiquidityUpdates,
1425    ) -> anyhow::Result<()> {
1426        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::PoolLiquidityUpdates(cmd));
1427        self.command_tx.send(command)?;
1428        Ok(())
1429    }
1430
1431    fn subscribe_pool_fee_collects(&mut self, cmd: SubscribePoolFeeCollects) -> anyhow::Result<()> {
1432        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::PoolFeeCollects(cmd));
1433        self.command_tx.send(command)?;
1434        Ok(())
1435    }
1436
1437    fn subscribe_pool_flash_events(&mut self, cmd: SubscribePoolFlashEvents) -> anyhow::Result<()> {
1438        let command = DefiDataCommand::Subscribe(DefiSubscribeCommand::PoolFlashEvents(cmd));
1439        self.command_tx.send(command)?;
1440        Ok(())
1441    }
1442
1443    fn unsubscribe_blocks(&mut self, cmd: &UnsubscribeBlocks) -> anyhow::Result<()> {
1444        let command = DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::Blocks(cmd.clone()));
1445        self.command_tx.send(command)?;
1446        Ok(())
1447    }
1448
1449    fn unsubscribe_pool(&mut self, cmd: &UnsubscribePool) -> anyhow::Result<()> {
1450        let command = DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::Pool(cmd.clone()));
1451        self.command_tx.send(command)?;
1452        Ok(())
1453    }
1454
1455    fn unsubscribe_pool_swaps(&mut self, cmd: &UnsubscribePoolSwaps) -> anyhow::Result<()> {
1456        let command = DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::PoolSwaps(cmd.clone()));
1457        self.command_tx.send(command)?;
1458        Ok(())
1459    }
1460
1461    fn unsubscribe_pool_liquidity_updates(
1462        &mut self,
1463        cmd: &UnsubscribePoolLiquidityUpdates,
1464    ) -> anyhow::Result<()> {
1465        let command =
1466            DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::PoolLiquidityUpdates(cmd.clone()));
1467        self.command_tx.send(command)?;
1468        Ok(())
1469    }
1470
1471    fn unsubscribe_pool_fee_collects(
1472        &mut self,
1473        cmd: &UnsubscribePoolFeeCollects,
1474    ) -> anyhow::Result<()> {
1475        let command =
1476            DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::PoolFeeCollects(cmd.clone()));
1477        self.command_tx.send(command)?;
1478        Ok(())
1479    }
1480
1481    fn unsubscribe_pool_flash_events(
1482        &mut self,
1483        cmd: &UnsubscribePoolFlashEvents,
1484    ) -> anyhow::Result<()> {
1485        let command =
1486            DefiDataCommand::Unsubscribe(DefiUnsubscribeCommand::PoolFlashEvents(cmd.clone()));
1487        self.command_tx.send(command)?;
1488        Ok(())
1489    }
1490
1491    fn request_pool_snapshot(&self, cmd: RequestPoolSnapshot) -> anyhow::Result<()> {
1492        let command = DefiDataCommand::Request(DefiRequestCommand::PoolSnapshot(cmd));
1493        self.command_tx.send(command)?;
1494        Ok(())
1495    }
1496}
1497
1498#[cfg(test)]
1499mod tests {
1500    use std::{str::FromStr, sync::Arc};
1501
1502    use alloy::primitives::{B256, I256, U160, U256, address};
1503    use nautilus_core::UnixNanos;
1504    use nautilus_model::defi::{Block, Blockchain, Chain, DexType, Pool, PoolIdentifier, Token};
1505    use rstest::rstest;
1506
1507    use super::*;
1508    use crate::events::{
1509        burn::BurnEvent, collect::CollectEvent, fee_protocol_collect::FeeProtocolCollectEvent,
1510        fee_protocol_update::FeeProtocolUpdateEvent, flash::FlashEvent, mint::MintEvent,
1511        swap::SwapEvent,
1512    };
1513
1514    const WETH_USDT_CREATION_BLOCK: u64 = 12_375_326;
1515
1516    fn fixture_hash(hash: &str) -> B256 {
1517        B256::from_str(hash).expect("fixture block hash must be valid")
1518    }
1519
1520    #[rstest]
1521    fn pool_event_missing_block_metadata_clears_after_block_cache_update() {
1522        let chain = Arc::new(
1523            Chain::from_chain_id(1)
1524                .expect("Ethereum chain should exist")
1525                .clone(),
1526        );
1527        let mut cache = BlockchainCache::new(chain);
1528        let msg = flash_message(42);
1529
1530        assert_eq!(
1531            BlockchainDataClient::pool_event_block_number(&msg),
1532            Some(42)
1533        );
1534        assert_eq!(
1535            BlockchainDataClient::pool_event_missing_block_metadata(&msg, &cache),
1536            Some(42)
1537        );
1538
1539        let block = test_block(
1540            42,
1541            "0x1111111111111111111111111111111111111111111111111111111111111111",
1542            1_700_000_000_000_000_000,
1543        );
1544        cache
1545            .cache_block_metadata(&block)
1546            .expect("test block hash must be valid");
1547
1548        assert_eq!(
1549            BlockchainDataClient::pool_event_missing_block_metadata(&msg, &cache),
1550            None
1551        );
1552    }
1553
1554    #[rstest]
1555    fn queue_pending_pool_message_drops_oldest_entry_at_cap() {
1556        let mut pending = VecDeque::new();
1557
1558        for block_number in 0..MAX_PENDING_POOL_MESSAGES {
1559            BlockchainDataClient::queue_pending_pool_message(
1560                &mut pending,
1561                swap_message(block_number as u64),
1562            );
1563        }
1564
1565        BlockchainDataClient::queue_pending_pool_message(
1566            &mut pending,
1567            swap_message(MAX_PENDING_POOL_MESSAGES as u64),
1568        );
1569
1570        assert_eq!(pending.len(), MAX_PENDING_POOL_MESSAGES);
1571        assert_eq!(
1572            BlockchainDataClient::pool_event_block_number(pending.front().unwrap()),
1573            Some(1)
1574        );
1575        assert_eq!(
1576            BlockchainDataClient::pool_event_block_number(pending.back().unwrap()),
1577            Some(MAX_PENDING_POOL_MESSAGES as u64)
1578        );
1579    }
1580
1581    #[rstest]
1582    fn drain_pending_pool_messages_releases_events_after_block_metadata_is_cached() {
1583        let chain = Arc::new(
1584            Chain::from_chain_id(1)
1585                .expect("Ethereum chain should exist")
1586                .clone(),
1587        );
1588        let mut cache = BlockchainCache::new(chain);
1589        let block_42 = test_block(
1590            42,
1591            "0x4242424242424242424242424242424242424242424242424242424242424242",
1592            1_700_000_000_000_000_000,
1593        );
1594        cache
1595            .cache_block_metadata(&block_42)
1596            .expect("test block hash must be valid");
1597        let mut pending = VecDeque::from([flash_message(41), flash_message(42)]);
1598
1599        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1600            &mut pending,
1601            &cache,
1602        );
1603
1604        assert_eq!(ready_messages.len(), 1);
1605        assert_eq!(
1606            BlockchainDataClient::pool_event_block_number(&ready_messages[0]),
1607            Some(42)
1608        );
1609        assert_eq!(pending.len(), 1);
1610        assert_eq!(
1611            BlockchainDataClient::pool_event_block_number(pending.front().unwrap()),
1612            Some(41)
1613        );
1614
1615        let block_41 = test_block(
1616            41,
1617            "0x4141414141414141414141414141414141414141414141414141414141414141",
1618            1_700_000_000_000_000_001,
1619        );
1620        cache
1621            .cache_block_metadata(&block_41)
1622            .expect("test block hash must be valid");
1623
1624        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1625            &mut pending,
1626            &cache,
1627        );
1628
1629        assert_eq!(ready_messages.len(), 1);
1630        assert_eq!(
1631            BlockchainDataClient::pool_event_block_number(&ready_messages[0]),
1632            Some(41)
1633        );
1634        assert!(pending.is_empty());
1635    }
1636
1637    #[rstest]
1638    fn ready_live_blockchain_message_queues_until_block_metadata_is_cached() {
1639        let chain = Arc::new(
1640            Chain::from_chain_id(1)
1641                .expect("Ethereum chain should exist")
1642                .clone(),
1643        );
1644        let mut cache = BlockchainCache::new(chain);
1645        let mut pending = VecDeque::new();
1646
1647        let message = BlockchainDataClient::ready_live_blockchain_message(
1648            flash_message(42),
1649            &cache,
1650            &mut pending,
1651        );
1652
1653        assert!(message.is_none());
1654        assert_eq!(pending.len(), 1);
1655        assert_eq!(
1656            BlockchainDataClient::pool_event_block_number(pending.front().unwrap()),
1657            Some(42)
1658        );
1659
1660        let block = test_block(
1661            42,
1662            "0x1111111111111111111111111111111111111111111111111111111111111111",
1663            1_700_000_000_000_000_000,
1664        );
1665        cache
1666            .cache_block_metadata(&block)
1667            .expect("test block hash must be valid");
1668
1669        let message = BlockchainDataClient::ready_live_blockchain_message(
1670            BlockchainMessage::Block(block),
1671            &cache,
1672            &mut pending,
1673        );
1674        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1675            &mut pending,
1676            &cache,
1677        );
1678
1679        assert!(matches!(message, Some(BlockchainMessage::Block(_))));
1680        assert_eq!(ready_messages.len(), 1);
1681        assert_eq!(
1682            BlockchainDataClient::pool_event_block_number(&ready_messages[0]),
1683            Some(42)
1684        );
1685        assert!(pending.is_empty());
1686    }
1687
1688    #[rstest]
1689    #[case(swap_message_with_identity)]
1690    #[case(mint_message_with_identity)]
1691    #[case(burn_message_with_identity)]
1692    #[case(collect_message_with_identity)]
1693    #[case(flash_message_with_identity)]
1694    #[case(fee_protocol_update_message_with_identity)]
1695    #[case(fee_protocol_collect_message_with_identity)]
1696    fn pool_event_with_mismatched_block_hash_defers_until_matching_metadata_arrives(
1697        #[case] message_with_identity: fn(
1698            u64,
1699            Option<&str>,
1700            PoolIdentifier,
1701            &str,
1702            u32,
1703        ) -> BlockchainMessage,
1704    ) {
1705        let chain = Arc::new(
1706            Chain::from_chain_id(1)
1707                .expect("Ethereum chain should exist")
1708                .clone(),
1709        );
1710        let mut cache = BlockchainCache::new(chain);
1711        let mut pending = VecDeque::new();
1712        let pool_identifier = weth_usdt_pool().pool_identifier;
1713
1714        let superseded = test_block(
1715            42,
1716            "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
1717            1_700_000_000_000_000_000,
1718        );
1719        cache
1720            .cache_block_metadata(&superseded)
1721            .expect("test block hash must be valid");
1722
1723        let message = BlockchainDataClient::ready_live_blockchain_message(
1724            message_with_identity(
1725                42,
1726                Some("0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"),
1727                pool_identifier,
1728                "0xdeadbeef",
1729                7,
1730            ),
1731            &cache,
1732            &mut pending,
1733        );
1734
1735        assert!(message.is_none());
1736        assert_eq!(pending.len(), 1);
1737
1738        let canonical = test_block(
1739            42,
1740            "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
1741            1_700_000_000_000_000_001,
1742        );
1743        cache
1744            .cache_block_metadata(&canonical)
1745            .expect("test block hash must be valid");
1746        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1747            &mut pending,
1748            &cache,
1749        );
1750
1751        assert_eq!(ready_messages.len(), 1);
1752        let expected_observed =
1753            fixture_hash("0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
1754        assert_eq!(
1755            BlockchainDataClient::pool_event_block_hash(&ready_messages[0]),
1756            Some(expected_observed)
1757        );
1758        let expected_cached =
1759            fixture_hash("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
1760        assert_eq!(cache.get_block_hash(42), Some(expected_cached));
1761        assert_eq!(
1762            cache.get_block_timestamp(42),
1763            Some(&UnixNanos::from(1_700_000_000_000_000_001))
1764        );
1765        assert!(pending.is_empty());
1766
1767        let message = BlockchainDataClient::ready_live_blockchain_message(
1768            message_with_identity(
1769                42,
1770                Some("0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
1771                pool_identifier,
1772                "0xf00",
1773                8,
1774            ),
1775            &cache,
1776            &mut pending,
1777        );
1778
1779        assert!(message.is_some());
1780        assert!(pending.is_empty());
1781    }
1782
1783    #[rstest]
1784    #[case(swap_message_with_identity)]
1785    #[case(mint_message_with_identity)]
1786    #[case(burn_message_with_identity)]
1787    #[case(collect_message_with_identity)]
1788    #[case(flash_message_with_identity)]
1789    #[case(fee_protocol_update_message_with_identity)]
1790    #[case(fee_protocol_collect_message_with_identity)]
1791    fn removed_pool_log_purges_matching_pending_message_before_metadata_release(
1792        #[case] message_with_identity: fn(
1793            u64,
1794            Option<&str>,
1795            PoolIdentifier,
1796            &str,
1797            u32,
1798        ) -> BlockchainMessage,
1799    ) {
1800        let chain = Arc::new(
1801            Chain::from_chain_id(1)
1802                .expect("Ethereum chain should exist")
1803                .clone(),
1804        );
1805        let mut cache = BlockchainCache::new(chain);
1806        let mut pending = VecDeque::new();
1807        let pool_identifier = weth_usdt_pool().pool_identifier;
1808
1809        let message = BlockchainDataClient::ready_live_blockchain_message(
1810            message_with_identity(42, None, pool_identifier, "0xdeadbeef", 42),
1811            &cache,
1812            &mut pending,
1813        );
1814
1815        assert!(message.is_none());
1816        assert_eq!(pending.len(), 1);
1817
1818        let message = BlockchainDataClient::ready_live_blockchain_message(
1819            removed_pool_message(pool_identifier, "0xdeadbeef", 42),
1820            &cache,
1821            &mut pending,
1822        );
1823
1824        assert!(message.is_none());
1825        assert!(pending.is_empty());
1826
1827        let block = test_block(
1828            42,
1829            "0x4242424242424242424242424242424242424242424242424242424242424242",
1830            1_700_000_000_000_000_000,
1831        );
1832        cache
1833            .cache_block_metadata(&block)
1834            .expect("test block hash must be valid");
1835        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1836            &mut pending,
1837            &cache,
1838        );
1839
1840        assert!(ready_messages.is_empty());
1841        assert!(pending.is_empty());
1842    }
1843
1844    #[rstest]
1845    fn removed_pool_log_purges_only_exact_identity_and_preserves_order() {
1846        let chain = Arc::new(
1847            Chain::from_chain_id(1)
1848                .expect("Ethereum chain should exist")
1849                .clone(),
1850        );
1851        let mut cache = BlockchainCache::new(chain);
1852        let pool_identifier = weth_usdt_pool().pool_identifier;
1853        let other_pool_identifier =
1854            PoolIdentifier::from_address(address!("2222222222222222222222222222222222222222"));
1855        let mut pending = VecDeque::from([
1856            swap_message_with_identity(42, None, other_pool_identifier, "0xdeadbeef", 42),
1857            swap_message_with_identity(42, None, pool_identifier, "0xdeadbeef", 42),
1858            swap_message_with_identity(42, None, pool_identifier, "0xdeadbef0", 42),
1859            swap_message_with_identity(42, None, pool_identifier, "0xdeadbeef", 43),
1860        ]);
1861        let expected = vec![
1862            (other_pool_identifier, "0xdeadbeef", 42),
1863            (pool_identifier, "0xdeadbef0", 42),
1864            (pool_identifier, "0xdeadbeef", 43),
1865        ];
1866
1867        let message = BlockchainDataClient::ready_live_blockchain_message(
1868            removed_pool_message(pool_identifier, "0xDEADBEEF", 42),
1869            &cache,
1870            &mut pending,
1871        );
1872
1873        assert!(message.is_none());
1874        let pending_identities: Vec<_> = pending.iter().map(swap_identity).collect();
1875        assert_eq!(pending_identities, expected);
1876
1877        let block = test_block(
1878            42,
1879            "0x4242424242424242424242424242424242424242424242424242424242424242",
1880            1_700_000_000_000_000_000,
1881        );
1882        cache
1883            .cache_block_metadata(&block)
1884            .expect("test block hash must be valid");
1885        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1886            &mut pending,
1887            &cache,
1888        );
1889
1890        let ready_identities: Vec<_> = ready_messages.iter().map(swap_identity).collect();
1891        assert_eq!(ready_identities, expected);
1892        assert!(pending.is_empty());
1893    }
1894
1895    #[rstest]
1896    fn removed_pool_log_without_pending_match_is_noop() {
1897        let chain = Arc::new(
1898            Chain::from_chain_id(1)
1899                .expect("Ethereum chain should exist")
1900                .clone(),
1901        );
1902        let mut cache = BlockchainCache::new(chain);
1903        let mut pending = VecDeque::new();
1904        let pool_identifier = weth_usdt_pool().pool_identifier;
1905
1906        let message = BlockchainDataClient::ready_live_blockchain_message(
1907            removed_pool_message(pool_identifier, "0xdeadbeef", 42),
1908            &cache,
1909            &mut pending,
1910        );
1911
1912        assert!(message.is_none());
1913        assert!(pending.is_empty());
1914
1915        let message = BlockchainDataClient::ready_live_blockchain_message(
1916            swap_message_with_identity(42, None, pool_identifier, "0xdeadbeef", 42),
1917            &cache,
1918            &mut pending,
1919        );
1920
1921        assert!(message.is_none());
1922        assert_eq!(pending.len(), 1);
1923
1924        let block = test_block(
1925            42,
1926            "0x4242424242424242424242424242424242424242424242424242424242424242",
1927            1_700_000_000_000_000_000,
1928        );
1929        cache
1930            .cache_block_metadata(&block)
1931            .expect("test block hash must be valid");
1932        let ready_messages = BlockchainDataClient::drain_pending_pool_messages_with_cached_metadata(
1933            &mut pending,
1934            &cache,
1935        );
1936
1937        assert_eq!(ready_messages.len(), 1);
1938        assert_eq!(
1939            swap_identity(&ready_messages[0]),
1940            (pool_identifier, "0xdeadbeef", 42)
1941        );
1942        assert!(pending.is_empty());
1943    }
1944
1945    fn removed_pool_message(
1946        pool_identifier: PoolIdentifier,
1947        transaction_hash: &str,
1948        log_index: u32,
1949    ) -> BlockchainMessage {
1950        BlockchainMessage::PoolLogRemoved {
1951            pool_identifier,
1952            transaction_hash: transaction_hash.to_string(),
1953            log_index,
1954        }
1955    }
1956
1957    fn swap_message(block_number: u64) -> BlockchainMessage {
1958        let pool = weth_usdt_pool();
1959        swap_message_with_identity(block_number, None, pool.pool_identifier, "0x1", 0)
1960    }
1961
1962    fn swap_message_with_identity(
1963        block_number: u64,
1964        block_hash: Option<&str>,
1965        pool_identifier: PoolIdentifier,
1966        transaction_hash: &str,
1967        log_index: u32,
1968    ) -> BlockchainMessage {
1969        let pool = weth_usdt_pool();
1970        let address = address!("1111111111111111111111111111111111111111");
1971
1972        BlockchainMessage::SwapEvent(SwapEvent::new(
1973            Arc::clone(&pool.dex),
1974            pool_identifier,
1975            block_number,
1976            block_hash.map(fixture_hash),
1977            transaction_hash.to_string(),
1978            0,
1979            log_index,
1980            address,
1981            address,
1982            I256::ZERO,
1983            I256::ZERO,
1984            U160::ZERO,
1985            0,
1986            0,
1987        ))
1988    }
1989
1990    fn swap_identity(msg: &BlockchainMessage) -> (PoolIdentifier, &str, u32) {
1991        let BlockchainMessage::SwapEvent(event) = msg else {
1992            panic!("expected swap message");
1993        };
1994
1995        (
1996            event.pool_identifier,
1997            &event.transaction_hash,
1998            event.log_index,
1999        )
2000    }
2001
2002    fn test_block(number: u64, hash: &str, timestamp: u64) -> Block {
2003        Block::new(
2004            hash.to_string(),
2005            "0x0".to_string(),
2006            number,
2007            Ustr::from("0x0000000000000000000000000000000000000000"),
2008            30_000_000,
2009            21_000,
2010            UnixNanos::from(timestamp),
2011            Some(Blockchain::Ethereum),
2012        )
2013    }
2014
2015    fn flash_message(block_number: u64) -> BlockchainMessage {
2016        let pool = weth_usdt_pool();
2017        flash_message_with_identity(block_number, None, pool.pool_identifier, "0x1", 0)
2018    }
2019
2020    fn flash_message_with_identity(
2021        block_number: u64,
2022        block_hash: Option<&str>,
2023        pool_identifier: PoolIdentifier,
2024        transaction_hash: &str,
2025        log_index: u32,
2026    ) -> BlockchainMessage {
2027        let pool = weth_usdt_pool();
2028        let address = address!("1111111111111111111111111111111111111111");
2029
2030        BlockchainMessage::FlashEvent(FlashEvent::new(
2031            Arc::clone(&pool.dex),
2032            pool_identifier,
2033            block_number,
2034            block_hash.map(fixture_hash),
2035            transaction_hash.to_string(),
2036            0,
2037            log_index,
2038            address,
2039            address,
2040            U256::ZERO,
2041            U256::ZERO,
2042            U256::ZERO,
2043            U256::ZERO,
2044        ))
2045    }
2046
2047    fn mint_message_with_identity(
2048        block_number: u64,
2049        block_hash: Option<&str>,
2050        pool_identifier: PoolIdentifier,
2051        transaction_hash: &str,
2052        log_index: u32,
2053    ) -> BlockchainMessage {
2054        let pool = weth_usdt_pool();
2055        let address = address!("1111111111111111111111111111111111111111");
2056
2057        BlockchainMessage::MintEvent(MintEvent::new(
2058            Arc::clone(&pool.dex),
2059            pool_identifier,
2060            block_number,
2061            block_hash.map(fixture_hash),
2062            transaction_hash.to_string(),
2063            0,
2064            log_index,
2065            address,
2066            address,
2067            0,
2068            0,
2069            0,
2070            U256::ZERO,
2071            U256::ZERO,
2072        ))
2073    }
2074
2075    fn burn_message_with_identity(
2076        block_number: u64,
2077        block_hash: Option<&str>,
2078        pool_identifier: PoolIdentifier,
2079        transaction_hash: &str,
2080        log_index: u32,
2081    ) -> BlockchainMessage {
2082        let pool = weth_usdt_pool();
2083        let address = address!("1111111111111111111111111111111111111111");
2084
2085        BlockchainMessage::BurnEvent(BurnEvent::new(
2086            Arc::clone(&pool.dex),
2087            pool_identifier,
2088            block_number,
2089            block_hash.map(fixture_hash),
2090            transaction_hash.to_string(),
2091            0,
2092            log_index,
2093            address,
2094            0,
2095            0,
2096            0,
2097            U256::ZERO,
2098            U256::ZERO,
2099        ))
2100    }
2101
2102    fn collect_message_with_identity(
2103        block_number: u64,
2104        block_hash: Option<&str>,
2105        pool_identifier: PoolIdentifier,
2106        transaction_hash: &str,
2107        log_index: u32,
2108    ) -> BlockchainMessage {
2109        let pool = weth_usdt_pool();
2110        let address = address!("1111111111111111111111111111111111111111");
2111
2112        BlockchainMessage::CollectEvent(CollectEvent::new(
2113            Arc::clone(&pool.dex),
2114            pool_identifier,
2115            block_number,
2116            block_hash.map(fixture_hash),
2117            transaction_hash.to_string(),
2118            0,
2119            log_index,
2120            address,
2121            address,
2122            0,
2123            0,
2124            0,
2125            0,
2126        ))
2127    }
2128
2129    fn fee_protocol_update_message_with_identity(
2130        block_number: u64,
2131        block_hash: Option<&str>,
2132        pool_identifier: PoolIdentifier,
2133        transaction_hash: &str,
2134        log_index: u32,
2135    ) -> BlockchainMessage {
2136        let pool = weth_usdt_pool();
2137
2138        BlockchainMessage::FeeProtocolUpdateEvent(FeeProtocolUpdateEvent::new(
2139            Arc::clone(&pool.dex),
2140            pool_identifier,
2141            block_number,
2142            block_hash.map(fixture_hash),
2143            transaction_hash.to_string(),
2144            0,
2145            log_index,
2146            0,
2147            0,
2148        ))
2149    }
2150
2151    fn fee_protocol_collect_message_with_identity(
2152        block_number: u64,
2153        block_hash: Option<&str>,
2154        pool_identifier: PoolIdentifier,
2155        transaction_hash: &str,
2156        log_index: u32,
2157    ) -> BlockchainMessage {
2158        let pool = weth_usdt_pool();
2159        let address = address!("1111111111111111111111111111111111111111");
2160
2161        BlockchainMessage::FeeProtocolCollectEvent(FeeProtocolCollectEvent::new(
2162            Arc::clone(&pool.dex),
2163            pool_identifier,
2164            block_number,
2165            block_hash.map(fixture_hash),
2166            transaction_hash.to_string(),
2167            0,
2168            log_index,
2169            address,
2170            address,
2171            0,
2172            0,
2173        ))
2174    }
2175
2176    fn weth_usdt_pool() -> Arc<Pool> {
2177        let chain = Arc::new(
2178            Chain::from_chain_id(1)
2179                .expect("Ethereum chain should exist")
2180                .clone(),
2181        );
2182        let dex = Arc::clone(
2183            &get_dex_extended(chain.name, &DexType::UniswapV3)
2184                .expect("Ethereum UniswapV3 should be registered")
2185                .dex,
2186        );
2187        let pool_address = address!("4e68ccd3e89f51c3074ca5072bbac773960dfa36");
2188        let token0 = Token::new(
2189            Arc::clone(&chain),
2190            address!("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
2191            "Wrapped Ether".to_string(),
2192            "WETH".to_string(),
2193            18,
2194        );
2195        let token1 = Token::new(
2196            Arc::clone(&chain),
2197            address!("dAC17F958D2ee523a2206206994597C13D831ec7"),
2198            "Tether USD".to_string(),
2199            "USDT".to_string(),
2200            6,
2201        );
2202
2203        Arc::new(Pool::new(
2204            chain,
2205            dex,
2206            pool_address,
2207            PoolIdentifier::from_address(pool_address),
2208            WETH_USDT_CREATION_BLOCK,
2209            token0,
2210            token1,
2211            Some(3_000),
2212            Some(60),
2213            UnixNanos::default(),
2214        ))
2215    }
2216}