release: bal-server-0.2.2

Cargo.toml

@@ -5,6 +5,7 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
+base64 = "0.22.1"
 bs58 = "0.4.0"
 bytes = "1.2"
 bitcoin = { version = "0.32.5" }
@@ -20,11 +21,13 @@ hyper = { version = "1.3.1", features = ["http1","server"] }
 hyper-util = { version = "0.1.3", features = ["tokio"] }
 http-body-util = "0.1"
 log = "0.4.21"
+openssl = { version = "0.10.74", features = ["vendored"] }
 sha2 = "0.10.8"
 serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.116"
 sqlite = "0.34.0"
 regex = "1.10.4"
+reqwest = { version = "0.12.24", features = ["json","socks"] }
 tokio = { version = "1", features = ["rt", "net","macros","rt-multi-thread"] }  # Keep only necessary runtime components
 zmq = "0.10.0"
 

src/bin/bal-pusher.rs

@@ -8,6 +8,7 @@ use bitcoincore_rpc_json::GetBlockchainInfoResult;
 use sqlite::{Value};
 use serde::Serialize;
 use serde::Deserialize;
+use serde_json::json;
 use std::env;
 use log::{info,warn,error,trace,debug};
 use zmq::{Context, Socket};
@@ -19,8 +20,18 @@ use std::collections::HashMap;
 use hex;
 use std::error::Error as StdError;
 
-const LOCKTIME_THRESHOLD:i64 = 5000000;
+use reqwest::Client as rClient;
+use openssl::hash::MessageDigest;
+use openssl::pkey::{PKey};
+use openssl::sign::Signer;
+use base64::{engine::general_purpose, Engine as _};
+use std::fs;
 
+
+
+
+const LOCKTIME_THRESHOLD:i64 = 5000000;
+const VERSION:&str = "0.0.1";
 #[derive(Debug, Clone,Serialize, Deserialize)]
 struct MyConfig {
     zmq_listener:   String,
@@ -31,8 +42,10 @@ struct MyConfig {
     testnet:        NetworkParams,
     signet:         NetworkParams,
     mainnet:        NetworkParams,
-
+    send_stats:     bool,
-
+    url:            String,
+    secret_code:    String,
+    ssl_key_path:   String
 }
 
 impl Default for MyConfig {
@@ -46,6 +59,10 @@ impl Default for MyConfig {
             testnet:        get_network_params_default(Network::Testnet),
             signet:         get_network_params_default(Network::Signet),
             mainnet:        get_network_params_default(Network::Bitcoin),
+            send_stats:     false,
+            url:            "http://localhost/".to_string(),
+            secret_code:    "xxx".to_string(),
+            ssl_key_path:   "privkey.pem".to_string(),
         }
     }
 }
@@ -148,7 +165,6 @@ fn get_client_from_cookie(url: &String,network: &NetworkParams)->Result<(Client,
                 Ok(client) => {
                     match client.get_blockchain_info(){
                         Ok(bcinfo) => {
-                            println!("cristoporco");
                             Ok((client,bcinfo))
                         },
                         Err(err) => {
@@ -177,7 +193,7 @@ fn get_client(network: &NetworkParams) -> Result<(Client,GetBlockchainInfoResult
         }
     }
 }
-fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(), Error> {
+async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(), Error> {
 
 
     /*let url = args.next().expect("Usage: <rpc_url> <username> <password>");
@@ -204,6 +220,7 @@ fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(), Err
             //}
             //let average_time = time_sum/11;
             info!("median time: {}",bcinfo.median_time);
+            //info!("height time: {}",bcinfo.median_time);
             info!("blocks: {}",bcinfo.blocks);
             debug!("best block hash: {}",bcinfo.best_block_hash);
 
@@ -279,13 +296,60 @@ fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(), Err
                     let _ = db.execute(&sql);
                 }
             }
+            let _ = send_stats_report(cfg, bcinfo).await;
         }
-        Err(_)=>{
+        Err(erx)=>{
-            panic!("impossible to get client")
+            panic!("impossible to get client {}",erx)
         }
     }
     Ok(())
 }
+async fn send_stats_report(cfg: &MyConfig, bcinfo: GetBlockchainInfoResult) -> Result<(),reqwest::Error>{
+    if cfg.send_stats {
+        debug!("sending report to welist");
+        let welist_url=env::var("WELIST_SERVER_URL").unwrap_or("https://welist.bitcoin-after.life".to_string());
+        
+        let client = rClient::new();
+        let url = format!("{}/ping",welist_url);
+        let chain=bcinfo.chain.to_string().to_lowercase();
+        let message = format!("{0}{1}{2}{3}{4}",cfg.url,chain,bcinfo.blocks,bcinfo.median_time,bcinfo.best_block_hash);
+        let sign = sign_message(cfg.ssl_key_path.as_str(),&message.as_str());
+        let response = client.post(url)                
+            .header("User-Agent", format!("bal-pusher/{}",VERSION))
+            .json(&json!(
+                    {
+                        "url":              cfg.url,
+                        "chain":            chain,
+                        "height":           bcinfo.blocks,
+                        "median_time":      bcinfo.median_time,
+                        "last_block_hash":  bcinfo.best_block_hash,
+                        "signature":        sign,
+                    }))
+            .send().await?;
+        let body = &(response.text().await?);
+        println!("Body: {}", body);
+    }else {
+        debug!("Not sending stats");
+    }
+    Ok(())
+
+
+}
+fn sign_message(private_key_path: &str, message: &str) -> String {
+    let key_data  = fs::read(private_key_path).unwrap();
+
+    let private_key = PKey::private_key_from_pem(&key_data).unwrap();
+
+    let mut signer = Signer::new(MessageDigest::sha256(), &private_key).unwrap();
+
+    signer.update(message.as_bytes()).unwrap();
+
+    let firma = signer.sign_to_vec().unwrap();
+
+    let firma_b64 = general_purpose::STANDARD.encode(&firma);
+
+    firma_b64
+}
 
 fn parse_env(cfg: &mut MyConfig){
     match env::var("BAL_PUSHER_ZMQ_LISTENER") {
@@ -308,6 +372,27 @@ fn parse_env(cfg: &mut MyConfig){
             cfg.bitcoin_dir = value;},
         Err(_) => {},
     }
+    match env::var("BAL_PUSHER_SEND_STATS") {
+        Ok(value) => {
+            cfg.send_stats = value.parse::<bool>().unwrap();
+        },
+        Err(_) => {},
+    }
+    match env::var("BAL_SERVER_URL") {
+        Ok(value) => {
+            cfg.url= value;},
+        Err(_) => {},
+    }
+    match env::var("WELIST_SECRET_CODE") {
+        Ok(value) => {
+            cfg.secret_code = value;},
+        Err(_) => {},
+    }
+    match env::var("SSL_KEY_PATH") {
+        Ok(value) => {
+            cfg.ssl_key_path = value;},
+        Err(_) => {},
+    }
     cfg.regtest = parse_env_netconfig(cfg,"regtest");
     cfg.signet = parse_env_netconfig(cfg,"signet");
     cfg.testnet = parse_env_netconfig(cfg,"testnet");
@@ -364,8 +449,8 @@ fn get_default_config()-> MyConfig {
     info!("Default configuration file path is: {:#?}", file);
     confy::load("bal-pusher",None).expect("cant_load")
 }
-
+#[tokio::main]
-fn main(){
+async fn main()-> std::io::Result<()>{
     env_logger::init();
     let mut cfg: MyConfig = match env::var("BAL_PUSHER_CONFIG_FILE") {
         Ok(value) => {
@@ -414,7 +499,7 @@ fn main(){
 
     socket.set_subscribe(b"").unwrap(); 
 
-    let _ = main_result(&cfg,network_params);
+    let _ = main_result(&cfg,network_params).await;
     info!("waiting new blocks..");
     let mut last_seq:Vec<u8>=[0;4].to_vec();
     loop {
@@ -437,7 +522,7 @@ fn main(){
         if topic == b"hashblock" {
             info!("NEW BLOCK: {}", hex::encode(&body));  
             //let cfg = cfg.clone();
-            let _ = main_result(&cfg,network_params);
+            let _ = main_result(&cfg,network_params).await;
         }
         thread::sleep(Duration::from_millis(100)); // Sleep for 100ms
     }

src/db.rs

@@ -131,4 +131,17 @@ pub fn execute_insert(db: &Connection,
     Ok(())
 
 }
+pub fn get_total_transaction_number(db: Connection, network: &String) -> Result<i64,Error> {
+    let mut stmt = db.prepare("SELECT COUNT(*) as total_number FROM tbl_tx where network = ?;").unwrap();
+    stmt.bind((1,Value::String(network.to_string()))).unwrap();
+    match stmt.next(){
+        Ok(State::Row)=>{
+            Ok(stmt.read::<i64,_>("total_number").unwrap())
+        },
+        Ok(sqlite::State::Done) => todo!(),
+        Err(err)=>Err(err)
 
+
+    }
+
+}