chore: cargo fmt

Author: lgalabru

src/bin.rs

@@ -17,8 +17,8 @@ mod macros;
 
 mod frontend;
 mod generate;
-mod integrate;
 mod indexer;
+mod integrate;
 mod poke;
 mod publish;
 mod runnner;

src/indexer/chains/bitcoin.rs

@@ -1,10 +1,10 @@
-use bitcoincore_rpc::{Auth, Client, RpcApi};
-use bitcoincore_rpc::bitcoin::hashes::Hash;
-use bitcoincore_rpc::bitcoin::BlockHash;
-use clarity_repl::clarity::util::hash::{hex_bytes};
 use crate::indexer::IndexerConfig;
 use crate::types::{BitcoinBlockData, BitcoinBlockMetadata, BlockIdentifier};
-use rocket::serde::json::{Value as JsonValue};
+use bitcoincore_rpc::bitcoin::hashes::Hash;
+use bitcoincore_rpc::bitcoin::BlockHash;
+use bitcoincore_rpc::{Auth, Client, RpcApi};
+use clarity_repl::clarity::util::hash::hex_bytes;
+use rocket::serde::json::Value as JsonValue;
 
 #[allow(dead_code)]
 #[derive(Deserialize)]
@@ -15,12 +15,16 @@ pub struct NewBurnBlock {
     burn_amount: u64,
 }
 
-pub fn standardize_bitcoin_block(indexer_config: &IndexerConfig, marshalled_block: JsonValue) -> BitcoinBlockData {
+pub fn standardize_bitcoin_block(
+    indexer_config: &IndexerConfig,
+    marshalled_block: JsonValue,
+) -> BitcoinBlockData {
     let mut transactions = vec![];
 
     let auth = Auth::UserPass(
         indexer_config.bitcoin_node_rpc_username.clone(),
-        indexer_config.bitcoin_node_rpc_password.clone());
+        indexer_config.bitcoin_node_rpc_password.clone(),
+    );
 
     let rpc = Client::new(&indexer_config.bitcoin_node_rpc_url, auth).unwrap();
 
@@ -33,7 +37,7 @@ pub fn standardize_bitcoin_block(indexer_config: &IndexerConfig, marshalled_bloc
         BlockHash::from_slice(&block_hash_bytes).unwrap()
     };
     let block = rpc.get_block(&block_hash).unwrap();
-    
+
     for txdata in block.txdata.iter() {
         // let _ = tx.send(DevnetEvent::debug(format!(
         //     "Tx.out: {:?}", txdata.output
@@ -54,4 +58,3 @@ pub fn standardize_bitcoin_block(indexer_config: &IndexerConfig, marshalled_bloc
         transactions: transactions,
     }
 }
-

src/indexer/chains/mod.rs

@@ -2,4 +2,4 @@ pub mod bitcoin;
 pub mod stacks;
 
 pub use bitcoin::standardize_bitcoin_block;
-pub use stacks::standardize_stacks_block;
+pub use stacks::standardize_stacks_block;

src/indexer/chains/stacks.rs

@@ -1,25 +1,21 @@
+use crate::indexer::AssetClassCache;
 use crate::indexer::{IndexerConfig, StacksChainContext};
 use crate::types::{
-    AccountIdentifier, Amount,
-    BlockIdentifier, Currency, CurrencyMetadata, CurrencyStandard,
+    AccountIdentifier, Amount, BlockIdentifier, Currency, CurrencyMetadata, CurrencyStandard,
     Operation, OperationIdentifier, OperationStatusKind, OperationType, StacksBlockData,
     StacksBlockMetadata, StacksTransactionData, StacksTransactionMetadata, TransactionIdentifier,
 };
 use crate::utils::stacks::{transactions, StacksRpc};
-use crate::indexer::AssetClassCache;
 use clarity_repl::clarity::codec::transaction::TransactionPayload;
 use clarity_repl::clarity::codec::{StacksMessageCodec, StacksTransaction};
-use clarity_repl::clarity::types::{
-    AssetIdentifier, BuffData, SequenceData, TupleData, Value as ClarityValue,
-};
-use clarity_repl::clarity::util::hash::{hex_bytes, Hash160};
-use rocket::serde::json::{Value as JsonValue};
+use clarity_repl::clarity::types::Value as ClarityValue;
+use clarity_repl::clarity::util::hash::hex_bytes;
+use rocket::serde::json::Value as JsonValue;
 use rocket::serde::Deserialize;
 use std::collections::HashMap;
+use std::convert::TryInto;
 use std::io::Cursor;
 use std::str;
-use std::convert::TryInto;
-
 
 #[allow(dead_code)]
 #[derive(Deserialize)]
@@ -162,17 +158,22 @@ struct ContractReadonlyCall {
     result: String,
 }
 
-pub fn standardize_stacks_block(indexer_config: &IndexerConfig, marshalled_block: JsonValue, ctx: &mut StacksChainContext) -> StacksBlockData {
-
+pub fn standardize_stacks_block(
+    indexer_config: &IndexerConfig,
+    marshalled_block: JsonValue,
+    ctx: &mut StacksChainContext,
+) -> StacksBlockData {
     let mut block: NewBlock = serde_json::from_value(marshalled_block).unwrap();
 
-    let pox_cycle_length: u64 = (ctx.pox_info.prepare_phase_block_length + ctx.pox_info.reward_phase_block_length).into();
+    let pox_cycle_length: u64 =
+        (ctx.pox_info.prepare_phase_block_length + ctx.pox_info.reward_phase_block_length).into();
     let current_len = block.burn_block_height - ctx.pox_info.first_burnchain_block_height;
     let pox_cycle_id: u32 = (current_len / pox_cycle_length).try_into().unwrap();
 
     let mut events = vec![];
     events.append(&mut block.events);
-    let transactions = block.transactions
+    let transactions = block
+        .transactions
         .iter()
         .map(|t| {
             let description = get_tx_description(&t.raw_tx);
@@ -216,7 +217,7 @@ pub fn standardize_stacks_block(indexer_config: &IndexerConfig, marshalled_block
             pox_cycle_length: pox_cycle_length.try_into().unwrap(),
         },
         transactions,
-    }   
+    }
 }
 
 pub fn get_value_description(raw_value: &str) -> String {
@@ -289,7 +290,6 @@ pub fn get_tx_description(raw_tx: &str) -> String {
     description
 }
 
-
 pub fn get_standardized_fungible_currency_from_asset_class_id(
     asset_class_id: &str,
     asset_class_cache: &mut HashMap<String, AssetClassCache>,
@@ -406,14 +406,14 @@ pub fn get_standardized_stacks_operations(
 ) -> Vec<Operation> {
     let mut operations = vec![];
     let mut operation_id = 0;
-    
+
     let mut i = 0;
     while i < events.len() {
         if events[i].txid == transaction.txid {
             let event = events.remove(i);
             if let Some(ref event_data) = event.stx_mint_event {
-                let data: STXMintEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: STXMintEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 operations.push(Operation {
                     operation_identifier: OperationIdentifier {
                         index: operation_id,
@@ -434,8 +434,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.stx_lock_event {
-                let data: STXLockEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: STXLockEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 operations.push(Operation {
                     operation_identifier: OperationIdentifier {
                         index: operation_id,
@@ -449,15 +449,18 @@ pub fn get_standardized_stacks_operations(
                         sub_account: None,
                     },
                     amount: Some(Amount {
-                        value: data.locked_amount.parse::<u64>().expect("Unable to parse u64"),
+                        value: data
+                            .locked_amount
+                            .parse::<u64>()
+                            .expect("Unable to parse u64"),
                         currency: get_stacks_currency(),
                     }),
                     metadata: None,
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.stx_burn_event {
-                let data: STXBurnEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: STXBurnEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 operations.push(Operation {
                     operation_identifier: OperationIdentifier {
                         index: operation_id,
@@ -478,8 +481,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.stx_transfer_event {
-                let data: STXTransferEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: STXTransferEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 operations.push(Operation {
                     operation_identifier: OperationIdentifier {
                         index: operation_id,
@@ -525,8 +528,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.nft_mint_event {
-                let data: NFTMintEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: NFTMintEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_non_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     &data.asset_identifier,
@@ -549,8 +552,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.nft_burn_event {
-                let data: NFTBurnEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: NFTBurnEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_non_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     &data.asset_identifier,
@@ -573,8 +576,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.nft_transfer_event {
-                let data: NFTTransferEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: NFTTransferEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_non_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     &data.asset_identifier,
@@ -622,8 +625,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.ft_mint_event {
-                let data: FTMintEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: FTMintEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     asset_class_cache,
@@ -649,8 +652,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.ft_burn_event {
-                let data: FTBurnEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: FTBurnEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     asset_class_cache,
@@ -676,8 +679,8 @@ pub fn get_standardized_stacks_operations(
                 });
                 operation_id += 1;
             } else if let Some(ref event_data) = event.ft_transfer_event {
-                let data: FTTransferEventData =
-                    serde_json::from_value(event_data.clone()).expect("Unable to decode event_data");
+                let data: FTTransferEventData = serde_json::from_value(event_data.clone())
+                    .expect("Unable to decode event_data");
                 let currency = get_standardized_fungible_currency_from_asset_class_id(
                     &data.asset_class_identifier,
                     asset_class_cache,

src/indexer/mod.rs

@@ -1,17 +1,17 @@
 pub mod chains;
 
-use crate::types::{BitcoinBlockData, StacksBlockData, BlockIdentifier};
-use rocket::serde::json::{Value as JsonValue};
-use std::collections::{VecDeque, HashMap};
+use crate::types::{BitcoinBlockData, BlockIdentifier, StacksBlockData};
+use rocket::serde::json::Value as JsonValue;
+use std::collections::{HashMap, VecDeque};
 
 pub enum BitcoinChainEvent {
     ChainUpdatedWithBlock(BitcoinBlockData),
-    ChainUpdatedWithReorg(Vec<BitcoinBlockData>)
+    ChainUpdatedWithReorg(Vec<BitcoinBlockData>),
 }
 
 pub enum StacksChainEvent {
     ChainUpdatedWithBlock(StacksBlockData),
-    ChainUpdatedWithReorg(Vec<StacksBlockData>)
+    ChainUpdatedWithReorg(Vec<StacksBlockData>),
 }
 
 #[derive(Deserialize, Debug, Clone, Default)]
@@ -68,10 +68,10 @@ impl StacksChainContext {
 }
 
 pub struct IndexerConfig {
-    stacks_node_rpc_url: String,
-    bitcoin_node_rpc_url: String,
-    bitcoin_node_rpc_username: String,
-    bitcoin_node_rpc_password: String,
+    pub stacks_node_rpc_url: String,
+    pub bitcoin_node_rpc_url: String,
+    pub bitcoin_node_rpc_username: String,
+    pub bitcoin_node_rpc_password: String,
 }
 
 pub struct Indexer {
@@ -82,7 +82,6 @@ pub struct Indexer {
 }
 
 impl Indexer {
-
     pub fn new(config: IndexerConfig) -> Indexer {
         let stacks_last_7_blocks = VecDeque::new();
         let bitcoin_last_7_blocks = VecDeque::new();
@@ -99,7 +98,8 @@ impl Indexer {
         let block = chains::standardize_bitcoin_block(&self.config, marshalled_block);
         if let Some(tip) = self.bitcoin_last_7_blocks.back() {
             if block.block_identifier.index == tip.index + 1 {
-                self.bitcoin_last_7_blocks.push_back(block.block_identifier.clone());
+                self.bitcoin_last_7_blocks
+                    .push_back(block.block_identifier.clone());
                 if self.bitcoin_last_7_blocks.len() > 7 {
                     self.bitcoin_last_7_blocks.pop_front();
                 }
@@ -111,16 +111,22 @@ impl Indexer {
                 // TODO: deeper reorg
             }
         } else {
-            self.bitcoin_last_7_blocks.push_front(block.block_identifier.clone());
+            self.bitcoin_last_7_blocks
+                .push_front(block.block_identifier.clone());
         }
         BitcoinChainEvent::ChainUpdatedWithBlock(block)
     }
 
     pub fn handle_stacks_block(&mut self, marshalled_block: JsonValue) -> StacksChainEvent {
-        let block = chains::standardize_stacks_block(&self.config, marshalled_block, &mut self.stacks_context);
+        let block = chains::standardize_stacks_block(
+            &self.config,
+            marshalled_block,
+            &mut self.stacks_context,
+        );
         if let Some(tip) = self.stacks_last_7_blocks.back() {
             if block.block_identifier.index == tip.index + 1 {
-                self.stacks_last_7_blocks.push_back(block.block_identifier.clone());
+                self.stacks_last_7_blocks
+                    .push_back(block.block_identifier.clone());
                 if self.stacks_last_7_blocks.len() > 7 {
                     self.stacks_last_7_blocks.pop_front();
                 }
@@ -132,12 +138,22 @@ impl Indexer {
                 // TODO: deeper reorg
             }
         } else {
-            self.stacks_last_7_blocks.push_front(block.block_identifier.clone());
+            self.stacks_last_7_blocks
+                .push_front(block.block_identifier.clone());
         }
         StacksChainEvent::ChainUpdatedWithBlock(block)
     }
 
     pub fn get_updated_pox_info(&mut self) -> PoxInfo {
+        // std::thread::spawn(move || {
+        //     let pox_url = format!("{}/v2/pox", node_url);
+
+        //     if let Ok(reponse) = reqwest::blocking::get(pox_url) {
+        //         if let Ok(update) = reponse.json() {
+        //             pox_info = update
+        //         }
+        //     }
+
         self.stacks_context.pox_info.clone()
     }
 }