1use 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#[derive(Debug)]
71pub struct BlockchainDataClient {
72 pub client_id: ClientId,
74 pub chain: SharedChain,
76 pub config: BlockchainDataClientConfig,
78 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 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 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, }
228 } => {
229 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 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 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 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 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 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 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 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}