refactor: leverage StacksRpc

Author: lgalabru

src/indexer/chains/bitcoin.rs

@@ -39,6 +39,7 @@ pub fn standardize_bitcoin_block(
     let block = rpc.get_block(&block_hash).unwrap();
 
     for txdata in block.txdata.iter() {
+        // TODO: retrieve stacks transactions
         // let _ = tx.send(DevnetEvent::debug(format!(
         //     "Tx.out: {:?}", txdata.output
         // )));

src/indexer/chains/stacks.rs

@@ -5,7 +5,7 @@ use crate::types::{
     Operation, OperationIdentifier, OperationStatusKind, OperationType, StacksBlockData,
     StacksBlockMetadata, StacksTransactionData, StacksTransactionMetadata, TransactionIdentifier,
 };
-use crate::utils::stacks::{transactions, StacksRpc};
+use crate::utils::stacks::StacksRpc;
 use clarity_repl::clarity::codec::transaction::TransactionPayload;
 use clarity_repl::clarity::codec::{StacksMessageCodec, StacksTransaction};
 use clarity_repl::clarity::types::Value as ClarityValue;
@@ -299,62 +299,33 @@ pub fn get_standardized_fungible_currency_from_asset_class_id(
         None => {
             let comps = asset_class_id.split("::").collect::<Vec<&str>>();
             let principal = comps[0].split(".").collect::<Vec<&str>>();
-
-            let get_symbol_request_url = format!(
-                "{}/v2/contracts/call-read/{}/{}/get-symbol",
-                node_url, principal[0], principal[1],
-            );
-
-            println!("get_standardized_fungible_currency_from_asset_class_id");
-
-            let symbol_res: ContractReadonlyCall = reqwest::blocking::get(&get_symbol_request_url)
-                .expect("Unable to retrieve account")
-                .json()
-                .expect("Unable to parse contract");
-
-            let raw_value = match symbol_res.result.strip_prefix("0x") {
-                Some(raw_value) => raw_value,
-                _ => panic!(),
-            };
-            let value_bytes = match hex_bytes(&raw_value) {
-                Ok(bytes) => bytes,
-                _ => panic!(),
-            };
-
-            let symbol = match ClarityValue::consensus_deserialize(&mut Cursor::new(&value_bytes)) {
-                Ok(value) => value.expect_result_ok().expect_u128(),
-                _ => panic!(),
-            };
-
-            let get_decimals_request_url = format!(
-                "{}/v2/contracts/call-read/{}/{}/get-decimals",
-                node_url, principal[0], principal[1],
-            );
-
-            let decimals_res: ContractReadonlyCall =
-                reqwest::blocking::get(&get_decimals_request_url)
-                    .expect("Unable to retrieve account")
-                    .json()
-                    .expect("Unable to parse contract");
-
-            let raw_value = match decimals_res.result.strip_prefix("0x") {
-                Some(raw_value) => raw_value,
-                _ => panic!(),
-            };
-            let value_bytes = match hex_bytes(&raw_value) {
-                Ok(bytes) => bytes,
-                _ => panic!(),
-            };
-
-            let value = match ClarityValue::consensus_deserialize(&mut Cursor::new(&value_bytes)) {
-                Ok(value) => value.expect_result_ok().expect_u128(),
-                _ => panic!(),
-            };
-
-            let entry = AssetClassCache {
-                symbol: format!("{}", symbol),
-                decimals: value as u8,
-            };
+            let contract_address = principal[0];
+            let contract_name = principal[1];
+
+            let stacks_rpc = StacksRpc::new(&node_url);
+            let value = stacks_rpc
+                .call_read_only_fn(
+                    &contract_address,
+                    &contract_name,
+                    "get-symbol",
+                    vec![],
+                    contract_address,
+                )
+                .expect("Unable to retrieve symbol");
+            let symbol = value.expect_result_ok().expect_ascii();
+
+            let value = stacks_rpc
+                .call_read_only_fn(
+                    &contract_address,
+                    &contract_name,
+                    "get-decimals",
+                    vec![],
+                    &contract_address,
+                )
+                .expect("Unable to retrieve decimals");
+            let decimals = value.expect_result_ok().expect_u128() as u8;
+
+            let entry = AssetClassCache { symbol, decimals };
 
             let currency = Currency {
                 symbol: entry.symbol.clone(),
@@ -385,7 +356,7 @@ pub fn get_standardized_fungible_currency_from_asset_class_id(
 pub fn get_standardized_non_fungible_currency_from_asset_class_id(
     asset_class_id: &str,
     asset_id: &str,
-    asset_class_cache: &mut HashMap<String, AssetClassCache>,
+    _asset_class_cache: &mut HashMap<String, AssetClassCache>,
 ) -> Currency {
     Currency {
         symbol: asset_class_id.into(),

src/indexer/mod.rs

@@ -1,6 +1,7 @@
 pub mod chains;
 
 use crate::types::{BitcoinBlockData, BlockIdentifier, StacksBlockData};
+use crate::utils::stacks::{PoxInfo, StacksRpc};
 use rocket::serde::json::Value as JsonValue;
 use std::collections::{HashMap, VecDeque};
 
@@ -27,19 +28,6 @@ pub struct StacksChainContext {
     pox_info: PoxInfo,
 }
 
-#[derive(Deserialize, Debug, Clone, Default)]
-pub struct PoxInfo {
-    pub contract_id: String,
-    pub pox_activation_threshold_ustx: u64,
-    pub first_burnchain_block_height: u64,
-    pub prepare_phase_block_length: u32,
-    pub reward_phase_block_length: u32,
-    pub reward_slots: u32,
-    pub reward_cycle_id: u32,
-    pub total_liquid_supply_ustx: u64,
-    pub next_cycle: PoxCycle,
-}
-
 impl PoxInfo {
     pub fn default() -> PoxInfo {
         PoxInfo {
@@ -55,11 +43,6 @@ impl PoxInfo {
     }
 }
 
-#[derive(Deserialize, Debug, Clone, Default)]
-pub struct PoxCycle {
-    pub min_threshold_ustx: u64,
-}
-
 impl StacksChainContext {
     pub fn new() -> StacksChainContext {
         StacksChainContext {
@@ -146,16 +129,15 @@ impl Indexer {
         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
-        //         }
-        //     }
-
+    pub fn get_updated_pox_info(&mut self, block: &StacksBlockData) -> PoxInfo {
+        let pox_cycle_len = self.stacks_context.pox_info.prepare_phase_block_length
+            + self.stacks_context.pox_info.reward_phase_block_length;
+        if block.metadata.pox_cycle_position == pox_cycle_len - 2 {
+            let stacks_rpc = StacksRpc::new(&self.config.stacks_node_rpc_url);
+            if let Ok(pox_info) = stacks_rpc.get_pox_info() {
+                self.stacks_context.pox_info = pox_info;
+            }
+        }
         self.stacks_context.pox_info.clone()
     }
 }

src/integrate/events_observer.rs

@@ -1,13 +1,11 @@
 use super::DevnetEvent;
-use crate::indexer::{
-    chains, BitcoinChainEvent, Indexer, IndexerConfig, PoxInfo, StacksChainEvent,
-};
+use crate::indexer::{chains, BitcoinChainEvent, Indexer, IndexerConfig, StacksChainEvent};
 use crate::integrate::{MempoolAdmissionData, ServiceStatusData, Status};
 use crate::poke::load_session;
 use crate::publish::{publish_contract, Network};
 use crate::types::{self, DevnetConfig};
 use crate::utils;
-use crate::utils::stacks::{transactions, StacksRpc};
+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};
@@ -292,23 +290,23 @@ pub fn handle_new_block(
     // Standardize the structure of the block, and identify the
     // kind of update that this new block would imply, taking
     // into account the last 7 blocks.
-    let (chain_update, pox_info) = match indexer.inner().write() {
+    let (pox_info, block) = match indexer.inner().write() {
         Ok(mut indexer) => {
             let chain_event = indexer.handle_stacks_block(marshalled_block.into_inner());
-            (chain_event, indexer.get_updated_pox_info())
-        }
-        _ => {
-            return Json(json!({
-                "status": 200,
-                "result": "Ok",
-            }))
+            // Contextual: Devnet is an environment under control,
+            // with 1 miner. As such we will ignore Reorgs handling.
+            match chain_event {
+                StacksChainEvent::ChainUpdatedWithBlock(block) => {
+                    (indexer.get_updated_pox_info(&block), block)
+                }
+                _ => {
+                    return Json(json!({
+                        "status": 200,
+                        "result": "Ok",
+                    }))
+                }
+            }
         }
-    };
-
-    // Contextual: Devnet is an environment under control,
-    // with 1 miner. As such we will ignore Reorgs handling.
-    let block = match chain_update {
-        StacksChainEvent::ChainUpdatedWithBlock(block) => block,
         _ => {
             return Json(json!({
                 "status": 200,
@@ -402,7 +400,8 @@ pub fn handle_new_block(
     data = "<new_microblock>"
 )]
 pub fn handle_new_microblocks(
-    _config: &State<Arc<RwLock<EventObserverConfig>>>,
+    _config: &State<Arc<Mutex<EventObserverConfig>>>,
+    _indexer: &State<Arc<RwLock<Indexer>>>,
     devnet_events_tx: &State<Arc<Mutex<Sender<DevnetEvent>>>>,
     new_microblock: Json<NewMicroBlock>,
 ) -> Json<JsonValue> {
@@ -567,10 +566,10 @@ pub fn publish_stacking_orders(
 
             transactions += 1;
 
-            let stacks_rpc = StacksRpc::new(node_url.clone());
+            let stacks_rpc = StacksRpc::new(&node_url);
             let default_fee = 1000;
             let nonce = stacks_rpc
-                .get_nonce(account.address.to_string())
+                .get_nonce(&account.address)
                 .expect("Unable to retrieve nonce");
 
             let stx_amount = pox_info.next_cycle.min_threshold_ustx * pox_stacking_order.slots;

src/publish/mod.rs

@@ -1,5 +1,6 @@
 use crate::poke::load_session;
 use crate::utils::mnemonic;
+use crate::utils::stacks::StacksRpc;
 use clarity_repl::clarity::codec::transaction::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionPayload, TransactionPostConditionMode, TransactionPublicKeyEncoding,
@@ -44,7 +45,7 @@ pub fn publish_contract(
     contract: &InitialContract,
     deployers_lookup: &BTreeMap<String, Account>,
     deployers_nonces: &mut BTreeMap<String, u64>,
-    node: &str,
+    node_url: &str,
     deployment_fee_rate: u64,
     network: &Network,
 ) -> Result<(String, u64), String> {
@@ -75,20 +76,14 @@ pub fn publish_contract(
     let anchor_mode = TransactionAnchorMode::Any;
     let tx_fee = deployment_fee_rate * contract.code.len() as u64;
 
+    let stacks_rpc = StacksRpc::new(&node_url);
+
     let nonce = match deployers_nonces.get(&deployer.name) {
         Some(nonce) => *nonce,
         None => {
-            let request_url = format!(
-                "{host}/v2/accounts/{addr}",
-                host = node,
-                addr = deployer.address,
-            );
-
-            let response: Balance = reqwest::blocking::get(&request_url)
-                .expect("Unable to retrieve account")
-                .json()
-                .expect("Unable to parse contract");
-            let nonce = response.nonce;
+            let nonce = stacks_rpc
+                .get_nonce(&deployer.address)
+                .expect("Unable to retrieve account");
             deployers_nonces.insert(deployer.name.clone(), nonce);
             nonce
         }
@@ -137,20 +132,10 @@ pub fn publish_contract(
     tx_signer.sign_origin(&wrapped_secret_key).unwrap();
     let signed_tx = tx_signer.get_tx().unwrap();
 
-    let tx_bytes = signed_tx.serialize_to_vec();
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{}/v2/transactions", node);
-    let res = client
-        .post(&path)
-        .header("Content-Type", "application/octet-stream")
-        .body(tx_bytes)
-        .send()
-        .unwrap();
-
-    if !res.status().is_success() {
-        return Err(format!("{}", res.text().unwrap()));
-    }
-    let txid: String = res.json().unwrap();
+    let txid = match stacks_rpc.post_transaction(signed_tx) {
+        Ok(res) => res.txid,
+        Err(e) => return Err(format!("{:?}", e)),
+    };
     deployers_nonces.insert(deployer.name.clone(), nonce + 1);
     Ok((txid, nonce))
 }

src/utils/stacks/mod.rs

@@ -1,4 +1,5 @@
 #[allow(dead_code)]
 pub mod rpc_client;
 pub mod transactions;
-pub use rpc_client::StacksRpc;
+
+pub use rpc_client::{PoxInfo, StacksRpc};