chore: cargo fmt

Author: lgalabru

src/indexer/mod.rs

@@ -134,9 +134,12 @@ impl Indexer {
     }
 
     pub async fn update_pox_info(&mut self) {
-        let res: Result<PoxInfo, _> = reqwest::get(format!("{}/v2/pox", self.config.stacks_node_rpc_url)).await
-            .expect("Unable to retrieve pox info")
-            .json().await;
+        let res: Result<PoxInfo, _> =
+            reqwest::get(format!("{}/v2/pox", self.config.stacks_node_rpc_url))
+                .await
+                .expect("Unable to retrieve pox info")
+                .json()
+                .await;
         if let Ok(ref pox_info) = res {
             self.stacks_context.pox_info = pox_info.clone();
         }

src/integrate/events_observer.rs

@@ -3,9 +3,9 @@ use crate::indexer::{chains, BitcoinChainEvent, Indexer, IndexerConfig, StacksCh
 use crate::integrate::{MempoolAdmissionData, ServiceStatusData, Status};
 use crate::poke::load_session;
 use crate::publish::{publish_contract, Network};
-use crate::types::{self, DevnetConfig, BlockIdentifier};
+use crate::types::{self, BlockIdentifier, DevnetConfig};
 use crate::utils;
-use crate::utils::stacks::{transactions, StacksRpc, PoxInfo};
+use crate::utils::stacks::{transactions, PoxInfo, StacksRpc};
 use base58::FromBase58;
 use clarity_repl::clarity::representations::ClarityName;
 use clarity_repl::clarity::types::{BuffData, SequenceData, TupleData, Value as ClarityValue};
@@ -225,12 +225,15 @@ pub async fn start_events_observer(
                     init_status.deployer_nonce = 0;
                 }
             }
-            Ok(EventsObserverCommand::UpdatePoxInfo) => {
-
-            }
+            Ok(EventsObserverCommand::UpdatePoxInfo) => {}
             Ok(EventsObserverCommand::PublishInitialContracts) => {
                 if let Ok(mut init_status_writer) = init_status_rw_lock.write() {
-                    let res = publish_initial_contracts(&config.devnet_config, &config.accounts, config.deployment_fee_rate, &mut init_status_writer);
+                    let res = publish_initial_contracts(
+                        &config.devnet_config,
+                        &config.accounts,
+                        config.deployment_fee_rate,
+                        &mut init_status_writer,
+                    );
                     if let Some(tx_count) = res {
                         let _ = devnet_event_tx.send(DevnetEvent::success(format!(
                             "Will publish {} contracts",
@@ -241,7 +244,13 @@ pub async fn start_events_observer(
             }
             Ok(EventsObserverCommand::PublishPoxStackingOrders(block_identifier)) => {
                 let bitcoin_block_height = block_identifier.index;
-                let res = publish_stacking_orders(&config.devnet_config, &config.accounts, config.deployment_fee_rate, bitcoin_block_height as u32).await;
+                let res = publish_stacking_orders(
+                    &config.devnet_config,
+                    &config.accounts,
+                    config.deployment_fee_rate,
+                    bitcoin_block_height as u32,
+                )
+                .await;
                 if let Some(tx_count) = res {
                     let _ = devnet_event_tx.send(DevnetEvent::success(format!(
                         "Will broadcast {} stacking orders",
@@ -354,7 +363,7 @@ pub fn handle_new_block(
         }
     };
 
-    // Partially update the UI. With current approach a full update 
+    // Partially update the UI. With current approach a full update
     // would requires either cloning the block, or passing ownership.
     let devnet_events_tx = devnet_events_tx.inner();
     if let Ok(tx) = devnet_events_tx.lock() {
@@ -394,7 +403,9 @@ pub fn handle_new_block(
     let should_submit_pox_orders = block.metadata.pox_cycle_position == (pox_cycle_length - 2);
     if should_submit_pox_orders {
         if let Ok(background_job_tx) = background_job_tx_mutex.lock() {
-            let _ = background_job_tx.send(EventsObserverCommand::PublishPoxStackingOrders(block.metadata.bitcoin_anchor_block_identifier.clone()));
+            let _ = background_job_tx.send(EventsObserverCommand::PublishPoxStackingOrders(
+                block.metadata.bitcoin_anchor_block_identifier.clone(),
+            ));
         }
     }
 
@@ -491,7 +502,6 @@ pub fn handle_ping() -> Json<JsonValue> {
     }))
 }
 
-
 pub fn publish_initial_contracts(
     devnet_config: &DevnetConfig,
     accounts: &Vec<Account>,
@@ -569,7 +579,7 @@ pub async fn publish_stacking_orders(
     }
 
     let stacks_node_rpc_url = format!("http://localhost:{}", devnet_config.stacks_node_rpc_port);
-    
+
     let mut transactions = 0;
     let pox_info: PoxInfo = reqwest::get(format!("{}/v2/pox", stacks_node_rpc_url))
         .await

src/integrate/mod.rs

@@ -81,7 +81,12 @@ pub async fn do_run_devnet(
     let (events_observer_commands_tx, events_observer_commands_rx) = channel();
     let moved_events_observer_commands_tx = events_observer_commands_tx.clone();
     let events_observer_handle = std::thread::spawn(move || {
-        let future = start_events_observer(config, events_observer_tx, events_observer_commands_rx, moved_events_observer_commands_tx);
+        let future = start_events_observer(
+            config,
+            events_observer_tx,
+            events_observer_commands_rx,
+            moved_events_observer_commands_tx,
+        );
         let rt = utils::create_basic_runtime();
         let _ = rt.block_on(future);
     });

src/integrate/ui/mod.rs

@@ -5,7 +5,7 @@ mod ui;
 #[allow(dead_code)]
 mod util;
 
-use super::{DevnetEvent, events_observer::EventsObserverCommand};
+use super::{events_observer::EventsObserverCommand, DevnetEvent};
 use app::App;
 use crossterm::{
     event::{self, Event, KeyCode, KeyModifiers},

src/utils/stacks/rpc_client.rs

@@ -50,7 +50,7 @@ struct Balance {
 
 impl StacksRpc {
     pub fn new(url: &str) -> Self {
-        Self { 
+        Self {
             url: url.into(),
             client: Client::builder().build().unwrap(),
         }
@@ -62,7 +62,8 @@ impl StacksRpc {
     ) -> Result<PostTransactionResult, RpcError> {
         let tx = transaction.serialize_to_vec();
         let path = format!("{}/v2/transactions", self.url);
-        let res = self.client
+        let res = self
+            .client
             .post(&path)
             .header("Content-Type", "application/octet-stream")
             .body(tx)
@@ -82,7 +83,9 @@ impl StacksRpc {
     pub fn get_nonce(&self, address: &str) -> Result<u64, RpcError> {
         let request_url = format!("{}/v2/accounts/{addr}", self.url, addr = address,);
 
-        let res: Balance = self.client.get(&request_url)
+        let res: Balance = self
+            .client
+            .get(&request_url)
             .send()
             .expect("Unable to retrieve account")
             .json()
@@ -94,7 +97,9 @@ impl StacksRpc {
     pub fn get_pox_info(&self) -> Result<PoxInfo, RpcError> {
         let request_url = format!("{}/v2/pox", self.url);
 
-        let res: PoxInfo = self.client.get(&request_url)
+        let res: PoxInfo = self
+            .client
+            .get(&request_url)
             .send()
             .expect("Unable to retrieve account")
             .json()
@@ -119,7 +124,8 @@ impl StacksRpc {
             .iter()
             .map(|a| bytes_to_hex(&a.serialize_to_vec()))
             .collect::<Vec<_>>();
-        let res = self.client
+        let res = self
+            .client
             .post(&path)
             .json(&json!({
                 "sender": sender,