bitcoinafterlife/bal-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

expose stats

Browse Source
This commit is contained in:
svatantrya
2026-01-21 00:08:47 -04:00
parent fa98283df6
commit dcaab2ed6d
6 changed files with 814 additions and 667 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
bal-pusher.sh
View File

@@ -1,12 +1,12 @@
RUST_LOG=trace RUST_LOG=trace
BAL_PUSHER_DB_FILE="$(pwd)/bal.db" export BAL_PUSHER_DB_FILE="$(pwd)/bal.db"
#export BAL_PUSHER_BITCOIN_COOKIE_FILE=/~/.bitcoin/.cookie #export BAL_PUSHER_BITCOIN_COOKIE_FILE=/~/.bitcoin/.cookie
#export BAL_PUSHER_REGTEST_COOKIE_FILE=/~/.bitcoin/regtest/.cookie #export BAL_PUSHER_REGTEST_COOKIE_FILE=/~/.bitcoin/regtest/.cookie
#export BAL_PUSHER_TESTNET_COOKIE_FILE=/~/.bitcoin/testnet3/.cookie #export BAL_PUSHER_TESTNET_COOKIE_FILE=/~/.bitcoin/testnet3/.cookie
#export BAL_PUSHER_SIGNET_COOKIE_FILE=/~/.bitcoin/signet/.cookie #export BAL_PUSHER_SIGNET_COOKIE_FILE=/~/.bitcoin/signet/.cookie
BAL_PUSHER_ZMQ_LISTENER=tcp://127.0.0.1:28332 export BAL_PUSHER_ZMQ_LISTENER=tcp://127.0.0.1:28332
export BAL_PUSHER_SEND_STATS=true export BAL_PUSHER_SEND_STATS=true
export WELIST_SERVER_URL=http://localhost:8085 export WELIST_SERVER_URL=http://localhost:8085
export BAL_SERVER_URL="http://127.0.0.1:9133" export BAL_SERVER_URL="http://127.0.0.1:9133"

1
bal-server.sh
View File

@@ -11,6 +11,7 @@ export BAL_SERVER_INFO="BAL devel willexecutor server"
export BAL_SERVER_BIND_ADDRESS="127.0.0.1" export BAL_SERVER_BIND_ADDRESS="127.0.0.1"
export BAL_SERVER_BIND_PORT=9133 export BAL_SERVER_BIND_PORT=9133
export BAL_SERVER_PUB_KEY_PATH="$WORKING_DIR/public_key.pem" export BAL_SERVER_PUB_KEY_PATH="$WORKING_DIR/public_key.pem"
export BAL_SERVER_EXPOSE_STATS=true;
#export BAL_SERVER_BITCOIN_ADDRESS="your bitcoin address or xpub to recive payments here" #export BAL_SERVER_BITCOIN_ADDRESS="your bitcoin address or xpub to recive payments here"
#export BAL_SERVER_BITCOIN_FIXED_FEE=50000 #export BAL_SERVER_BITCOIN_FIXED_FEE=50000

521
src/bin/bal-pusher.rs
View File

@@ -2,45 +2,38 @@ extern crate bitcoincore_rpc;
extern crate zmq; extern crate zmq;
use bitcoin::Network; use bitcoin::Network;
use bitcoincore_rpc::{bitcoin, Auth, Client, Error, RpcApi}; use bitcoincore_rpc::{Auth, Client, Error, RpcApi, bitcoin};
use bitcoincore_rpc_json::GetBlockchainInfoResult; use bitcoincore_rpc_json::GetBlockchainInfoResult;
use sqlite::{Value}; use byteorder::{LittleEndian, ReadBytesExt};
use serde::Serialize; use hex;
use log::{debug, error, info, trace, warn};
use serde::Deserialize; use serde::Deserialize;
use serde::Serialize;
use serde_json::json; use serde_json::json;
use sqlite::{Value, Connection};
use std::collections::HashMap;
use std::env; use std::env;
use log::{info,warn,error,trace,debug}; use std::error::Error as StdError;
use zmq::{Context, Socket, DEALER, DONTWAIT}; use std::io::Cursor;
use std::str; use std::str;
use std::{thread, time::Duration}; use std::{thread, time::Duration};
use std::collections::HashMap; use zmq::{Context, DEALER, DONTWAIT, Socket};
use byteorder::{LittleEndian, ReadBytesExt};
use std::io::Cursor;
use hex;
use std::error::Error as StdError;
use reqwest::Client as rClient; use base64::{Engine as _, engine::general_purpose};
use openssl::hash::MessageDigest; use openssl::hash::MessageDigest;
use openssl::pkey::{PKey}; use openssl::pkey::PKey;
use openssl::sign::Signer; use openssl::sign::Signer;
use openssl::sign::Verifier; use openssl::sign::Verifier;
use base64::{engine::general_purpose, Engine as _}; use reqwest::Client as rClient;
use std::fs; use std::fs;
use std::time::Instant; use std::time::Instant;
const LOCKTIME_THRESHOLD: i64 = 5000000;
const VERSION: &str = "0.0.2";
#[derive(Debug, Clone, Serialize, Deserialize)]
const LOCKTIME_THRESHOLD:i64 = 5000000;
const VERSION:&str = "0.0.2";
#[derive(Debug, Clone,Serialize, Deserialize)]
struct MyConfig { struct MyConfig {
zmq_listener: String, zmq_listener: String,
requests_file: String,
db_file: String, db_file: String,
bitcoin_dir: String, bitcoin_dir: String,
regtest: NetworkParams, regtest: NetworkParams,
@@ -49,25 +42,22 @@ struct MyConfig {
mainnet: NetworkParams, mainnet: NetworkParams,
send_stats: bool, send_stats: bool,
url: String, url: String,
secret_code: String, ssl_key_path: String,
ssl_key_path: String
} }
impl Default for MyConfig { impl Default for MyConfig {
fn default() -> Self { fn default() -> Self {
MyConfig { MyConfig {
zmq_listener: "tcp://127.0.0.1:28332".to_string(), zmq_listener: env::var("BAL_PUSHER_ZMQ_LISTENER").unwrap_or("tcp://127.0.0.1:28332".to_string()),
requests_file: "rawrequests.log".to_string(), db_file: env::var("BAL_PUSHER_DB_FILE").unwrap_or("bal.db".to_string()),
db_file: "../bal.db".to_string(), bitcoin_dir: env::var("BAL_PUSHER_BITCOIN_DIR").unwrap_or("".to_string()),
bitcoin_dir: "".to_string(),
regtest: get_network_params_default(Network::Regtest), regtest: get_network_params_default(Network::Regtest),
testnet: get_network_params_default(Network::Testnet), testnet: get_network_params_default(Network::Testnet),
signet: get_network_params_default(Network::Signet), signet: get_network_params_default(Network::Signet),
mainnet: get_network_params_default(Network::Bitcoin), mainnet: get_network_params_default(Network::Bitcoin),
send_stats: false, send_stats: env::var("BAL_PUSHER_SEND_STATS").unwrap_or("false".to_string()).parse::<bool>().unwrap(),
url: "http://localhost/".to_string(), url: env::var("BAL_SERVER_URL").unwrap_or("http://localhost/".to_string()),
secret_code: "xxx".to_string(), ssl_key_path: env::var("SSL_KEY_PATH").unwrap_or("privkey.pem".to_string()),
ssl_key_path: "privkey.pem".to_string(),
} }
} }
} }
@@ -82,17 +72,17 @@ struct NetworkParams {
rpc_user: String, rpc_user: String,
rpc_pass: String, rpc_pass: String,
} }
fn get_network_params(cfg: &MyConfig,network:Network)-> &NetworkParams{ fn get_network_params(cfg: &MyConfig, network: Network) -> &NetworkParams {
match network{ match network {
Network::Testnet => &cfg.testnet, Network::Testnet => &cfg.testnet,
Network::Signet => &cfg.signet, Network::Signet => &cfg.signet,
Network::Regtest => &cfg.regtest, Network::Regtest => &cfg.regtest,
_ => &cfg.mainnet _ => &cfg.mainnet,
} }
} }
fn get_network_params_default(network:Network) -> NetworkParams{ fn get_network_params_default(network: Network) -> NetworkParams {
match network { match network {
Network::Testnet => NetworkParams{ Network::Testnet => NetworkParams {
host: "http://i27.0.0.1".to_string(), host: "http://i27.0.0.1".to_string(),
port: 18332, port: 18332,
dir_path: "testnet3/".to_string(), dir_path: "testnet3/".to_string(),
@@ -101,7 +91,7 @@ fn get_network_params_default(network:Network) -> NetworkParams{
rpc_user: "".to_string(), rpc_user: "".to_string(),
rpc_pass: "".to_string(), rpc_pass: "".to_string(),
}, },
Network::Signet => NetworkParams{ Network::Signet => NetworkParams {
host: "http://127.0.0.1".to_string(), host: "http://127.0.0.1".to_string(),
port: 18332, port: 18332,
dir_path: "signet/".to_string(), dir_path: "signet/".to_string(),
@@ -110,7 +100,7 @@ fn get_network_params_default(network:Network) -> NetworkParams{
rpc_user: "".to_string(), rpc_user: "".to_string(),
rpc_pass: "".to_string(), rpc_pass: "".to_string(),
}, },
Network::Regtest => NetworkParams{ Network::Regtest => NetworkParams {
host: "http://127.0.0.1".to_string(), host: "http://127.0.0.1".to_string(),
port: 18443, port: 18443,
dir_path: "regtest/".to_string(), dir_path: "regtest/".to_string(),
@@ -119,7 +109,7 @@ fn get_network_params_default(network:Network) -> NetworkParams{
rpc_user: "".to_string(), rpc_user: "".to_string(),
rpc_pass: "".to_string(), rpc_pass: "".to_string(),
}, },
_ => NetworkParams{ _ => NetworkParams {
host: "http://127.0.0.1".to_string(), host: "http://127.0.0.1".to_string(),
port: 8332, port: 8332,
dir_path: "".to_string(), dir_path: "".to_string(),
@@ -131,83 +121,78 @@ fn get_network_params_default(network:Network) -> NetworkParams{
} }
} }
fn get_cookie_filename(network: &NetworkParams) ->Result<String,Box<dyn StdError>>{ fn get_cookie_filename(network: &NetworkParams) -> Result<String, Box<dyn StdError>> {
if network.cookie_file !=""{ if network.cookie_file != "" {
Ok(network.cookie_file.clone()) Ok(network.cookie_file.clone())
}else{ } else {
match env::var_os("HOME") { match env::var_os("HOME") {
Some(home) => { Some(home) => match home.to_str() {
match home.to_str(){
Some(home_str) => { Some(home_str) => {
let cookie_file_path = format!("{}/.bitcoin/{}.cookie",home_str, network.dir_path); let cookie_file_path =
format!("{}/.bitcoin/{}.cookie", home_str, network.dir_path);
Ok(cookie_file_path) Ok(cookie_file_path)
},
None => Err("wrong HOME value".into())
} }
None => Err("wrong HOME value".into()),
}, },
None => Err("Please Set HOME environment variable".into()) None => Err("Please Set HOME environment variable".into()),
} }
} }
} }
fn get_client_from_username(url: &String, network: &NetworkParams) -> Result<(Client,GetBlockchainInfoResult),Box<dyn StdError>>{ fn get_client_from_username(
url: &String,
network: &NetworkParams,
) -> Result<(Client, GetBlockchainInfoResult), Box<dyn StdError>> {
if network.rpc_user != "" { if network.rpc_user != "" {
match Client::new(&url[..],Auth::UserPass(network.rpc_user.to_string(),network.rpc_pass.to_string())){ match Client::new(
Ok(client) => match client.get_blockchain_info(){ &url[..],
Ok(bcinfo) => Ok((client,bcinfo)), Auth::UserPass(network.rpc_user.to_string(), network.rpc_pass.to_string()),
Err(err) => Err(err.into()) ) {
Ok(client) => match client.get_blockchain_info() {
Ok(bcinfo) => Ok((client, bcinfo)),
Err(err) => Err(err.into()),
},
Err(err) => Err(err.into()),
} }
Err(err)=>Err(err.into()) } else {
}
}else{
Err("Failed".into()) Err("Failed".into())
} }
} }
fn get_client_from_cookie(url: &String,network: &NetworkParams)->Result<(Client,GetBlockchainInfoResult),Box<dyn StdError>>{ fn get_client_from_cookie(
match get_cookie_filename(network){ url: &String,
Ok(cookie) => { network: &NetworkParams,
match Client::new(&url[..], Auth::CookieFile(cookie.into())) { ) -> Result<(Client, GetBlockchainInfoResult), Box<dyn StdError>> {
Ok(client) => { match get_cookie_filename(network) {
match client.get_blockchain_info(){ Ok(cookie) => match Client::new(&url[..], Auth::CookieFile(cookie.into())) {
Ok(bcinfo) => { Ok(client) => match client.get_blockchain_info() {
Ok((client,bcinfo)) Ok(bcinfo) => Ok((client, bcinfo)),
Err(err) => Err(err.into()),
}, },
Err(err) => { Err(err) => Err(err.into()),
Err(err.into())
}
}
}, },
Err(err)=>Err(err.into()) Err(err) => Err(err.into()),
}
},
Err(err)=>Err(err.into())
} }
} }
fn get_client(network: &NetworkParams) -> Result<(Client,GetBlockchainInfoResult),Box<dyn StdError>>{ fn get_client(
let url = format!("{}:{}/",network.host,&network.port); network: &NetworkParams,
match get_client_from_username(&url,network){ ) -> Result<(Client, GetBlockchainInfoResult), Box<dyn StdError>> {
Ok(client) =>{Ok(client)}, let url = format!("{}:{}/", network.host, &network.port);
Err(_) =>{ match get_client_from_username(&url, network) {
match get_client_from_cookie(&url,&network){ Ok(client) => Ok(client),
Ok(client)=>{ Err(_) => match get_client_from_cookie(&url, &network) {
Ok(client) Ok(client) => Ok(client),
Err(err) => Err(err.into()),
}, },
Err(err)=> Err(err.into())
}
}
} }
} }
async 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>"); /*let url = args.next().expect("Usage: <rpc_url> <username> <password>");
let user = args.next().expect("no user given"); let user = args.next().expect("no user given");
let pass = args.next().expect("no pass given"); let pass = args.next().expect("no pass given");
*/ */
//let network = Network::Regtest //let network = Network::Regtest
match get_client(network_params){ match get_client(network_params) {
Ok((rpc,bcinfo)) => { Ok((rpc, bcinfo)) => {
info!("connected"); info!("connected");
//let best_block_hash = rpc.get_best_block_hash()?; //let best_block_hash = rpc.get_best_block_hash()?;
//info!("best block hash: {}", best_block_hash); //info!("best block hash: {}", best_block_hash);
@@ -224,41 +209,44 @@ async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(
// time_sum += <u32 as Into<u64>>::into(block.header.time); // time_sum += <u32 as Into<u64>>::into(block.header.time);
//} //}
//let average_time = time_sum/11; //let average_time = time_sum/11;
info!("median time: {}",bcinfo.median_time); info!("median time: {}", bcinfo.median_time);
//info!("height time: {}",bcinfo.median_time); //info!("height time: {}",bcinfo.median_time);
info!("blocks: {}",bcinfo.blocks); info!("blocks: {}", bcinfo.blocks);
debug!("best block hash: {}",bcinfo.best_block_hash); debug!("best block hash: {}", bcinfo.best_block_hash);
let average_time = bcinfo.median_time; let average_time = bcinfo.median_time;
let db = sqlite::open(&cfg.db_file).unwrap(); let db = sqlite::open(&cfg.db_file).unwrap();
info!("db open {}",&cfg.db_file);
let sqlquery = "SELECT * FROM tbl_tx WHERE network = :network AND status = :status AND ( locktime < :bestblock_height OR locktime > :locktime_threshold AND locktime < :bestblock_time);"; let sqlquery = "SELECT * FROM tbl_tx WHERE network = :network AND status = :status AND ( locktime < :bestblock_height OR locktime > :locktime_threshold AND locktime < :bestblock_time);";
let query_tx = db.prepare(sqlquery).unwrap().into_iter(); let query_tx = db.prepare(sqlquery).unwrap().into_iter();
trace!("query_tx: {}",sqlquery); trace!("query_tx: {}", sqlquery);
trace!(":locktime_threshold: {}", LOCKTIME_THRESHOLD ); trace!(":locktime_threshold: {}", LOCKTIME_THRESHOLD);
trace!(":bestblock_time: {}", average_time); trace!(":bestblock_time: {}", average_time);
trace!(":bestblock_height: {}", bcinfo.blocks); trace!(":bestblock_height: {}", bcinfo.blocks);
trace!(":network: {}", network_params.db_field.clone()); trace!(":network: {}", network_params.db_field.clone());
trace!(":status: {}", 0); trace!(":status: {}", 0);
//let query_tx = db.prepare("SELECT * FROM tbl_tx where status = :status").unwrap().into_iter(); //let query_tx = db.prepare("SELECT * FROM tbl_tx where status = :status").unwrap().into_iter();
let mut pushed_txs:Vec<String> = Vec::new(); let mut pushed_txs: Vec<String> = Vec::new();
let mut invalid_txs: std::collections::HashMap<String, String> = HashMap::new(); let mut invalid_txs: std::collections::HashMap<String, String> = HashMap::new();
for row in query_tx.bind::<&[(_, Value)]>(&[ for row in query_tx
.bind::<&[(_, Value)]>(
&[
(":locktime_threshold", (LOCKTIME_THRESHOLD as i64).into()), (":locktime_threshold", (LOCKTIME_THRESHOLD as i64).into()),
(":bestblock_time", (average_time as i64).into()), (":bestblock_time", (average_time as i64).into()),
(":bestblock_height", (bcinfo.blocks as i64).into()), (":bestblock_height", (bcinfo.blocks as i64).into()),
(":network", network_params.db_field.clone().into()), (":network", network_params.db_field.clone().into()),
(":status", 0.into()), (":status", 0.into()),
][..]) ][..],
)
.unwrap() .unwrap()
.map(|row| row.unwrap()) .map(|row| row.unwrap())
{ {
let tx = row.read::<&str, _>("tx"); let tx = row.read::<&str, _>("tx");
let txid = row.read::<&str, _>("txid"); let txid = row.read::<&str, _>("txid");
let locktime = row.read::<i64,_>("locktime"); let locktime = row.read::<i64, _>("locktime");
info!("to be pushed: {}: {}",txid, locktime); info!("to be pushed: {}: {}", txid, locktime);
match rpc.send_raw_transaction(tx){ match rpc.send_raw_transaction(tx) {
Ok(o) => { Ok(o) => {
/*let mut file = OpenOptions::new() /*let mut file = OpenOptions::new()
.append(true) // Set the append option .append(true) // Set the append option
@@ -268,9 +256,9 @@ async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(
file.write_all(data.as_bytes())?; file.write_all(data.as_bytes())?;
drop(file); drop(file);
*/ */
info!("tx: {} pusshata PUSHED\n{}",txid,o); info!("tx: {} pusshata PUSHED\n{}", txid, o);
pushed_txs.push(txid.to_string()); pushed_txs.push(txid.to_string());
}, }
Err(err) => { Err(err) => {
/*let mut file = OpenOptions::new() /*let mut file = OpenOptions::new()
.append(true) // Set the append option .append(true) // Set the append option
@@ -280,49 +268,132 @@ async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(
file.write_all(data.as_bytes())?; file.write_all(data.as_bytes())?;
drop(file); drop(file);
*/ */
warn!("Error: {}\n{}",err,txid); warn!("Error: {}\n{}", err, txid);
//store err in invalid_txs //store err in invalid_txs
invalid_txs.insert(txid.to_string(), err.to_string()); invalid_txs.insert(txid.to_string(), err.to_string());
}
},
}; };
} }
if pushed_txs.len() > 0 { if pushed_txs.len() > 0 {
let sql = format!("UPDATE tbl_tx SET status = 1 WHERE txid in ('{}');",pushed_txs.join("','")); let sql = format!(
trace!("sqlok: {}",&sql); "UPDATE tbl_tx SET status = 1 WHERE txid in ('{}');",
pushed_txs.join("','")
);
trace!("sqlok: {}", &sql);
let _ = db.execute(&sql); let _ = db.execute(&sql);
} }
if invalid_txs.len() > 0 { if invalid_txs.len() > 0 {
for (txid,txerr) in &invalid_txs{ for (txid, txerr) in &invalid_txs {
//let _ = db.execute(format!("UPDATE tbl_tx SET status = 2 WHERE txid in ('{}'Yp);",invalid_txs.join("','"))); //let _ = db.execute(format!("UPDATE tbl_tx SET status = 2 WHERE txid in ('{}'Yp);",invalid_txs.join("','")));
let sql = format!("UPDATE tbl_tx SET status = 2, push_err='{txerr}' WHERE txid = '{txid}'"); let sql = format!(
trace!("sqlerror: {}",&sql); "UPDATE tbl_tx SET status = 2, push_err='{txerr}' WHERE txid = '{txid}'"
);
trace!("sqlerror: {}", &sql);
let _ = db.execute(&sql); let _ = db.execute(&sql);
} }
} }
let _ = send_stats_report(cfg, bcinfo).await; let _ = send_stats_report(cfg, bcinfo).await;
let _ = calculate_stats(&db,network_params.db_field.clone()).await;
} }
Err(erx)=>{ Err(erx) => {
panic!("impossible to get client {}",erx) panic!("impossible to get client {}", erx)
} }
} }
Ok(()) Ok(())
} }
async fn send_stats_report(cfg: &MyConfig, bcinfo: GetBlockchainInfoResult) -> Result<(),reqwest::Error>{ async fn calculate_stats(db: &Connection,chain: String) -> Result<(), reqwest::Error> {
//let sql = "drop table if exists tbl_stats;";
let sql = "DELETE FROM tbl_stats WHERE chain = '{chain}';";
if let Err(err) = db.execute(&sql){
error!("error deleting from tbl_stats where chain:{chain} error: {err}");
}
let sql = format!("INSERT INTO tbl_stats (
report_date, chain, totals, waiting, sent, failed,
waiting_profit, sent_profit, missed_profit, unique_inputs
)
VALUES (
CURRENT_TIMESTAMP,
'{chain}',
(SELECT COUNT(*) FROM tbl_tx WHERE network = '{chain}'),
(SELECT COUNT(*) FROM tbl_tx WHERE status = 0 AND network = '{chain}'),
(SELECT COUNT(*) FROM tbl_tx WHERE status = 1 AND network = '{chain}'),
(SELECT COUNT(*) FROM tbl_tx WHERE status = 2 AND network = '{chain}'),
(SELECT IFNULL(SUM(our_fees),0) FROM tbl_tx WHERE status = 0 AND network = '{chain}'),
(SELECT IFNULL(SUM(our_fees),0) FROM tbl_tx WHERE status = 1 AND network = '{chain}'),
(SELECT IFNULL(SUM(our_fees),0) FROM tbl_tx WHERE status = 2 AND network = '{chain}'),
(SELECT COUNT(DISTINCT tbl_inp.in_txid) -- or appropriate input identifier
FROM tbl_inp
JOIN tbl_tx ON tbl_inp.txid = tbl_tx.txid
WHERE tbl_tx.status = 0 AND tbl_tx.network = '{chain}')
)
ON CONFLICT(chain) DO UPDATE SET
report_date = excluded.report_date,
totals = excluded.totals,
waiting = excluded.waiting,
sent = excluded.sent,
failed = excluded.failed,
waiting_profit = excluded.waiting_profit,
sent_profit = excluded.sent_profit,
missed_profit = excluded.missed_profit,
unique_inputs = excluded.unique_inputs;
");
/*
let sql = format!("CREATE TABLE tbl_stats AS
SELECT
CURRENT_TIMESTAMP AS report_date,
'{chain}' as chain,
(SELECT COUNT(*) FROM tbl_tx WHERE network ='{chain}') AS totals,
(SELECT COUNT(*) FROM tbl_tx WHERE status = 0 AND network ='{chain}') AS waiting,
(SELECT COUNT(*) FROM tbl_tx WHERE status = 1 AND network ='{chain}') AS sent,
(SELECT COUNT(*) FROM tbl_tx WHERE status = 2 AND network ='{chain}') AS failed,
(SELECT SUM(our_fees) FROM tbl_tx WHERE status = 0 AND network ='{chain}') AS waiting_profit,
(SELECT SUM(our_fees) OR 0 FROM tbl_tx WHERE status = 1 AND network ='{chain}') AS sent_profit,
(SELECT SUM(our_fees) FROM tbl_tx WHERE status = 2 AND network ='{chain}') AS missed_profit,
(SELECT COUNT(*) FROM tbl_inp JOIN tbl_tx ON(tbl_inp.txid = tbl_tx.txid) WHERE tbl_tx.status=0 AND tbl_tx.network ='{chain}') AS unique_inputs;
");
let sql = "UPDATE tbl_stats set
totals = (SELECT COUNT(*) FROM tbl_tx WHERE network ='{chain}'),
waiting = (SELECT COUNT(*) FROM tbl_tx WHERE status = 0 AND network ='{chain}'),
sent = (SELECT COUNT(*) FROM tbl_tx WHERE status = 1 AND network ='{chain}'),
failed = (SELECT COUNT(*) FROM tbl_tx WHERE status = 1 AND network ='{chain}'),
waiting_profit = (SELECT SUM(our_fees) FROM tbl_tx WHERE status = 0 AND network ='{chain}'),
sent_profit = (SELECT SUM(our_fees) FROM tbl_tx WHERE status = 0 AND network ='{chain}'),
missed_profit = (SELECT SUM(our_fees) FROM tbl_tx WHERE status = 0 AND network ='{chain}')
unique_inputs = (SELECT COUNT(*) FROM tbl_inp JOIN tbl_tx ON(tbl_inp.txid = tbl_tx.txid) WHERE tbl_tx.status=0 AND tbl_tx.network ='{chain}')
WHERE chain = '{chain}'
*/
if let Err(err) = db.execute(&sql){
error!("error inserting creating stats table {err}");
}
else{
info!("tbl_stats creation success");
}
Ok(())
}
async fn send_stats_report(
cfg: &MyConfig,
bcinfo: GetBlockchainInfoResult,
) -> Result<(), reqwest::Error> {
if cfg.send_stats { if cfg.send_stats {
debug!("sending report to welist"); debug!("sending report to welist");
let welist_url=env::var("WELIST_SERVER_URL").unwrap_or("https://welist.bitcoin-after.life".to_string()); let welist_url = env::var("WELIST_SERVER_URL")
.unwrap_or("https://welist.bitcoin-after.life".to_string());
let client = rClient::new(); let client = rClient::new();
let url = format!("{}/ping",welist_url); let url = format!("{}/ping", welist_url);
debug!("welist url: {}",url); debug!("welist url: {}", url);
let chain=bcinfo.chain.to_string().to_lowercase(); 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 message = format!(
trace!("message to be sent: {}",message); "{0}{1}{2}{3}{4}",
let sign = sign_message(cfg.ssl_key_path.as_str(),&message.as_str()); cfg.url, chain, bcinfo.blocks, bcinfo.median_time, bcinfo.best_block_hash
let response = client.post(url) );
.header("User-Agent", format!("bal-pusher/{}",VERSION)) trace!("message to be sent: {}", message);
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!( .json(&json!(
{ {
"url": cfg.url, "url": cfg.url,
@@ -332,19 +403,22 @@ async fn send_stats_report(cfg: &MyConfig, bcinfo: GetBlockchainInfoResult) -> R
"last_block_hash": bcinfo.best_block_hash, "last_block_hash": bcinfo.best_block_hash,
"signature": sign, "signature": sign,
})) }))
.send().await?; .send()
.await?;
if !response.status().is_success() { if !response.status().is_success() {
warn!("Non-success response: {} {}", response.status(), response.status().canonical_reason().unwrap_or("")); warn!(
"Non-success response: {} {}",
response.status(),
response.status().canonical_reason().unwrap_or("")
);
} }
let body = &(response.text().await?); let body = &(response.text().await?);
info!("Report to welist({})\tSent: {}", welist_url,body); info!("Report to welist({})\tSent: {}", welist_url, body);
}else { } else {
debug!("Not sending stats"); debug!("Not sending stats");
} }
Ok(()) Ok(())
} }
fn sign_message(private_key_path: &str, message: &str) -> String { fn sign_message(private_key_path: &str, message: &str) -> String {
let key_data = fs::read(private_key_path).unwrap(); let key_data = fs::read(private_key_path).unwrap();
@@ -354,110 +428,73 @@ fn sign_message(private_key_path: &str, message: &str) -> String {
let signature = signer.sign_oneshot_to_vec(message.as_bytes()).unwrap(); let signature = signer.sign_oneshot_to_vec(message.as_bytes()).unwrap();
let signature_b64 = general_purpose::STANDARD.encode(&signature); let signature_b64 = general_purpose::STANDARD.encode(&signature);
signature_b64 signature_b64
} }
fn parse_env(cfg: &mut MyConfig){ fn parse_env(cfg: &mut MyConfig) {
match env::var("BAL_PUSHER_ZMQ_LISTENER") { cfg.regtest = parse_env_netconfig(cfg, "regtest");
Ok(value) => { cfg.signet = parse_env_netconfig(cfg, "signet");
cfg.zmq_listener = value;}, cfg.testnet = parse_env_netconfig(cfg, "testnet");
Err(_) => {}, drop(parse_env_netconfig(cfg, "bitcoin"));
}
match env::var("BAL_PUSHER_REQUEST_FILE") {
Ok(value) => {
cfg.requests_file = value;},
Err(_) => {},
}
match env::var("BAL_PUSHER_DB_FILE") {
Ok(value) => {
cfg.db_file = value;},
Err(_) => {},
}
match env::var("BAL_PUSHER_BITCOIN_DIR") {
Ok(value) => {
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");
drop(parse_env_netconfig(cfg,"bitcoin"));
} }
fn parse_env_netconfig(cfg_lock: &mut MyConfig, chain: &str) -> NetworkParams{ fn parse_env_netconfig(cfg_lock: &mut MyConfig, chain: &str) -> NetworkParams {
//fn parse_env_netconfig(cfg_lock: &MutexGuard<MyConfig>, chain: &str) -> &NetworkParams{ //fn parse_env_netconfig(cfg_lock: &MutexGuard<MyConfig>, chain: &str) -> &NetworkParams{
let cfg = match chain{ let cfg = match chain {
"regtest" => &mut cfg_lock.regtest, "regtest" => &mut cfg_lock.regtest,
"signet" => &mut cfg_lock.signet, "signet" => &mut cfg_lock.signet,
"testnet" => &mut cfg_lock.testnet, "testnet" => &mut cfg_lock.testnet,
&_ => &mut cfg_lock.mainnet, &_ => &mut cfg_lock.mainnet,
}; };
match env::var(format!("BAL_PUSHER_{}_HOST",chain.to_uppercase())) { match env::var(format!("BAL_PUSHER_{}_HOST", chain.to_uppercase())) {
Ok(value) => { cfg.host= value; },
Err(_) => {},
}
match env::var(format!("BAL_PUSHER_{}_PORT",chain.to_uppercase())) {
Ok(value) => { Ok(value) => {
match value.parse::<u64>(){ cfg.host = value;
Ok(value) =>{ cfg.port = value.try_into().unwrap(); },
Err(_) => {},
} }
Err(_) => {}
} }
Err(_) => {}, match env::var(format!("BAL_PUSHER_{}_PORT", chain.to_uppercase())) {
} Ok(value) => match value.parse::<u64>() {
match env::var(format!("BAL_PUSHER_{}_DIR_PATH",chain.to_uppercase())) {
Ok(value) => { cfg.dir_path = value; },
Err(_) => {},
}
match env::var(format!("BAL_PUSHER_{}_DB_FIELD",chain.to_uppercase())) {
Ok(value) => { cfg.db_field = value; },
Err(_) => {},
}
match env::var(format!("BAL_PUSHER_{}_COOKIE_FILE",chain.to_uppercase())) {
Ok(value) => { Ok(value) => {
cfg.cookie_file = value; }, cfg.port = value.try_into().unwrap();
Err(_) => {},
} }
match env::var(format!("BAL_PUSHER_{}_RPC_USER",chain.to_uppercase())) { Err(_) => {}
Ok(value) => { cfg.rpc_user = value; }, },
Err(_) => {}, Err(_) => {}
} }
match env::var(format!("BAL_PUSHER_{}_RPC_PASSWORD",chain.to_uppercase())) { match env::var(format!("BAL_PUSHER_{}_DIR_PATH", chain.to_uppercase())) {
Ok(value) => { cfg.rpc_pass = value; }, Ok(value) => {
Err(_) => {}, cfg.dir_path = value;
}
Err(_) => {}
}
match env::var(format!("BAL_PUSHER_{}_DB_FIELD", chain.to_uppercase())) {
Ok(value) => {
cfg.db_field = value;
}
Err(_) => {}
}
match env::var(format!("BAL_PUSHER_{}_COOKIE_FILE", chain.to_uppercase())) {
Ok(value) => {
cfg.cookie_file = value;
}
Err(_) => {}
}
match env::var(format!("BAL_PUSHER_{}_RPC_USER", chain.to_uppercase())) {
Ok(value) => {
cfg.rpc_user = value;
}
Err(_) => {}
}
match env::var(format!("BAL_PUSHER_{}_RPC_PASSWORD", chain.to_uppercase())) {
Ok(value) => {
cfg.rpc_pass = value;
}
Err(_) => {}
} }
cfg.clone() cfg.clone()
} }
fn get_default_config()-> MyConfig {
let file = confy::get_configuration_file_path("bal-pusher",None).expect("Error while getting path");
info!("Default configuration file path is: {:#?}", file);
confy::load("bal-pusher",None).expect("cant_load")
}
fn check_zmq_connection(endpoint: &str) -> bool { fn check_zmq_connection(endpoint: &str) -> bool {
trace!("check zmq connection"); trace!("check zmq connection");
@@ -527,78 +564,66 @@ enum ConnectionStatus {
} }
#[tokio::main] #[tokio::main]
async fn main()-> std::io::Result<()>{ async fn main() -> std::io::Result<()> {
env_logger::init(); env_logger::init();
let mut cfg: MyConfig = match env::var("BAL_PUSHER_CONFIG_FILE") { let mut cfg = MyConfig::default();
Ok(value) => {
match confy::load_path(&value){
Ok(val) => {
info!("The configuration file path is: {:#?}", value);
val
},
Err(err) => {
error!("{}",err);
get_default_config()
}
}
},
Err(_) => {
get_default_config()
},
};
let dbfile = env::var("BAL_PUSHER_DB_FILE").unwrap();
parse_env(&mut cfg); parse_env(&mut cfg);
let mut args = std::env::args(); let mut args = std::env::args();
let _exe_name = args.next().unwrap(); let _exe_name = args.next().unwrap();
let arg_network = match args.next(){ let arg_network = match args.next() {
Some(nargs) => nargs, Some(nargs) => nargs,
None => "bitcoin".to_string() None => "bitcoin".to_string(),
}; };
let network = match arg_network.as_str(){ let network = match arg_network.as_str() {
"testnet" => Network::Testnet, "testnet" => Network::Testnet,
"signet" => Network::Signet, "signet" => Network::Signet,
"regtest" => Network::Regtest, "regtest" => Network::Regtest,
_ => Network::Bitcoin, _ => Network::Bitcoin,
}; };
info!("Network: {}", arg_network);
info!("Network: {}",arg_network); let network_params = get_network_params(&cfg, network);
let network_params = get_network_params(&cfg,network);
let context = Context::new(); let context = Context::new();
let socket: Socket = context.socket(zmq::SUB).unwrap(); let socket: Socket = context.socket(zmq::SUB).unwrap();
let zmq_address = cfg.zmq_listener.clone(); let zmq_address = cfg.zmq_listener.clone();
info!("zmq listening on: {}",zmq_address); info!("zmq listening on: {}", zmq_address);
socket.connect(&zmq_address).unwrap(); socket.connect(&zmq_address).unwrap();
socket.set_subscribe(b"").unwrap(); socket.set_subscribe(b"").unwrap();
let _ = main_result(&cfg,network_params).await; let _ = main_result(&cfg, network_params).await;
info!("waiting new blocks.."); info!("waiting new blocks..");
let mut last_seq:Vec<u8>=[0;4].to_vec(); let mut last_seq: Vec<u8> = [0; 4].to_vec();
let mut counter=0; let mut counter = 0;
let max=100; let max = 100;
loop { loop {
let message = socket.recv_multipart(0).unwrap(); let message = socket.recv_multipart(0).unwrap();
let topic = message[0].clone(); let topic = message[0].clone();
let body = message[1].clone(); let body = message[1].clone();
let seq = message[2].clone(); let seq = message[2].clone();
last_seq = seq; last_seq = seq;
debug!("ZMQ:GET TOPIC: {}", String::from_utf8(topic.clone()).expect("invalid topic")); debug!(
"ZMQ:GET TOPIC: {}",
String::from_utf8(topic.clone()).expect("invalid topic")
);
trace!("ZMQ:GET BODY: {}", hex::encode(&body)); trace!("ZMQ:GET BODY: {}", hex::encode(&body));
if topic == b"hashblock" { if topic == b"hashblock" {
info!("NEW BLOCK: {}", hex::encode(&body)); info!("NEW BLOCK: {}", hex::encode(&body));
let _ = main_result(&cfg,network_params).await; let _ = main_result(&cfg, network_params).await;
} }
thread::sleep(Duration::from_millis(100)); // Sleep for 100ms thread::sleep(Duration::from_millis(100)); // Sleep for 100ms
} }
} }
fn seq_to_str(seq:&Vec<u8>) -> String{ fn seq_to_str(seq: &Vec<u8>) -> String {
if seq.len()==4{ if seq.len() == 4 {
let mut rdr = Cursor::new(seq); let mut rdr = Cursor::new(seq);
let sequence = rdr.read_u32::<LittleEndian>().expect("Failed to read integer"); let sequence = rdr
.read_u32::<LittleEndian>()
.expect("Failed to read integer");
return sequence.to_string(); return sequence.to_string();
} }
"Unknown".to_string() "Unknown".to_string()

447
src/bin/bal-server.rs
View File

@@ -1,37 +1,39 @@
use bytes::Bytes; use bytes::Bytes;
use http_body_util::{ combinators::BoxBody, BodyExt, Empty, Full }; use http_body_util::{BodyExt, Empty, Full, combinators::BoxBody};
use hyper::server::conn::http1; use hyper::server::conn::http1;
use hyper::service::service_fn; use hyper::service::service_fn;
use hyper::{ Method, Request, Response, StatusCode }; use hyper::{Method, Request, Response, StatusCode};
use tokio::net::TcpListener;
use hyper_util::rt::TokioIo; use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;
use std::net::IpAddr;
use std::env; use std::env;
use std::net::IpAddr;
//use std::time::{SystemTime,UNIX_EPOCH}; //use std::time::{SystemTime,UNIX_EPOCH};
use std::fs; use std::fs;
use std::sync::{ Arc, Mutex, MutexGuard }; use std::sync::{Arc, Mutex, MutexGuard};
//use std::net::SocketAddr; //use std::net::SocketAddr;
use sqlite::{Connection, State, Value};
use std::collections::HashMap; use std::collections::HashMap;
use sqlite::{ State, Value, Connection };
use bitcoin::{ consensus, Transaction, Network }; use bitcoin::{Network, Transaction, consensus};
use hex_conservative::FromHex;
use regex::Regex;
use serde::{ Serialize, Deserialize};
use log::{ info, error, trace, debug};
use serde_json;
use chrono::Utc; use chrono::Utc;
use hex_conservative::FromHex;
use log::{debug, error, info, trace};
use regex::Regex;
use serde::{Deserialize, Serialize};
use serde_json;
use bal_server::db::{ create_database, get_next_address_index, insert_xpub, save_new_address, get_last_used_address_by_ip, execute_insert }; use bal_server::db::{
create_database, execute_insert, get_last_used_address_by_ip, get_next_address_index,
insert_xpub, save_new_address,
};
use bal_server::xpub::new_address_from_xpub; use bal_server::xpub::new_address_from_xpub;
const VERSION:&str=env!("CARGO_PKG_VERSION"); const VERSION: &str = env!("CARGO_PKG_VERSION");
const NETWORKS : [&str; 4]= ["bitcoin","testnet","signet","regtest"]; const NETWORKS: [&str; 4] = ["bitcoin", "testnet", "signet", "regtest"];
#[derive(Debug, Clone,Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
struct NetConfig { struct NetConfig {
address: String, address: String,
fixed_fee: u64, fixed_fee: u64,
@@ -42,7 +44,7 @@ struct NetConfig {
} }
impl NetConfig { impl NetConfig {
fn default_network(name:String, network: Network) -> Self { fn default_network(name: String, network: Network) -> Self {
NetConfig { NetConfig {
address: "".to_string(), address: "".to_string(),
fixed_fee: 50000, fixed_fee: 50000,
@@ -54,7 +56,7 @@ impl NetConfig {
} }
} }
#[derive(Debug, Serialize, Deserialize,Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
struct MyConfig { struct MyConfig {
regtest: NetConfig, regtest: NetConfig,
signet: NetConfig, signet: NetConfig,
@@ -65,17 +67,30 @@ struct MyConfig {
bind_port: u16, // Changed to u16 for port numbers bind_port: u16, // Changed to u16 for port numbers
db_file: String, db_file: String,
pub_key_path: String, pub_key_path: String,
expose_stats: bool,
} }
#[derive(Debug,Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
pub struct Info { pub struct Info {
pub address: String, pub address: String,
pub base_fee: u64, pub base_fee: u64,
pub chain: String, pub chain: String,
pub info: String, pub info: String,
pub version: String pub version: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Stats {
pub report_date: String,
pub chain: String,
pub totals:i64,
pub waiting:i64,
pub sent:i64,
pub failed:i64,
pub waiting_profit:i64,
pub sent_profit:i64,
pub missed_profit:i64,
pub unique_inputs:i64,
} }
impl Default for MyConfig { impl Default for MyConfig {
fn default() -> Self { fn default() -> Self {
@@ -89,11 +104,12 @@ impl Default for MyConfig {
db_file: "bal.db".to_string(), db_file: "bal.db".to_string(),
info: "Will Executor Server".to_string(), info: "Will Executor Server".to_string(),
pub_key_path: "public_key.pem".to_string(), pub_key_path: "public_key.pem".to_string(),
expose_stats:env::var("BAL_SERVER_EXPOSE_STATS").unwrap_or("false".to_string()).parse::<bool>().unwrap(),
} }
} }
} }
impl MyConfig { impl MyConfig {
fn get_net_config(&self, param: &str) -> &NetConfig{ fn get_net_config(&self, param: &str) -> &NetConfig {
match param { match param {
"regtest" => &self.regtest, "regtest" => &self.regtest,
"testnet" => &self.testnet, "testnet" => &self.testnet,
@@ -103,85 +119,145 @@ impl MyConfig {
} }
} }
async fn echo_version( async fn echo_version() -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
Ok(Response::new(full(VERSION))) Ok(Response::new(full(VERSION)))
} }
async fn echo_home(cfg: &MyConfig async fn echo_home(cfg: &MyConfig) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { debug!("echo_home: {}", cfg.info);
debug!("echo_home: {}", cfg.info );
Ok(Response::new(full(cfg.info.clone()))) Ok(Response::new(full(cfg.info.clone())))
} }
async fn echo_pub_key( async fn echo_pub_key(
cfg: &MyConfig, cfg: &MyConfig,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
let pub_key = fs::read_to_string(&cfg.pub_key_path) let pub_key = fs::read_to_string(&cfg.pub_key_path)
.expect(format!("Failed to read public key file {}",cfg.pub_key_path).as_str()); .expect(format!("Failed to read public key file {}", cfg.pub_key_path).as_str());
Ok(Response::new(full(pub_key))) Ok(Response::new(full(pub_key)))
} }
async fn echo_stats(
param: &str,
cfg: &MyConfig,
remote_addr: &String,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
info!("echo stats!!! {} - {}", param,cfg.expose_stats);
let netconfig = MyConfig::get_net_config(cfg, param);
if !netconfig.enabled {
debug!("network disabled {}", param);
return Ok(Response::new(full("network disabled")));
}
let sql = format!("SELECT
report_date,
chain,
totals,
waiting,
sent,
failed,
waiting_profit,
sent_profit,
missed_profit,
unique_inputs FROM tbl_stats where chain = '{}'
", netconfig.name);
let mut stats:Vec<Stats>=vec![];
let db = sqlite::open(&cfg.db_file).unwrap();
db.iterate(&sql,|pairs|{
let row: HashMap<_, _> = pairs.into_iter().map(|(k,v)| (k.to_string(), v.map(|s| s))).collect();
//let row:HashMap<_,_>= pairs.into_iter().collect();
println!("row report date {}",row["report_date"].clone().unwrap());
dbg!(&row);
stats.push(Stats{
report_date: row["report_date"].clone().unwrap().to_string(),
chain: row["chain"].clone().unwrap().to_string(),
totals: row["totals"].clone().unwrap().parse::<i64>().unwrap(),
waiting: row["waiting"].clone().unwrap().parse::<i64>().unwrap(),
sent: row["sent"].clone().unwrap().parse::<i64>().unwrap(),
failed: row["failed"].clone().unwrap().parse::<i64>().unwrap(),
waiting_profit: row["waiting_profit"].clone().unwrap().parse::<i64>().unwrap(),
sent_profit: row["sent_profit"].clone().unwrap().parse::<i64>().unwrap(),
missed_profit:row["missed_profit"].clone().unwrap().parse::<i64>().unwrap(),
unique_inputs: row["unique_inputs"].clone().unwrap().parse::<i64>().unwrap(),
});
true
});
match serde_json::to_string(&stats) {
Ok(json_data) => {
debug!("echo info reply: {}", json_data);
return Ok(Response::new(full(json_data)));
}
Err(err) => Ok(Response::new(full(format!("error:{}", err)))),
}
}
async fn echo_info( async fn echo_info(
param: &str, param: &str,
cfg: &MyConfig, cfg: &MyConfig,
remote_addr: String, remote_addr: &String,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
info!("echo info!!!{}",param); info!("echo info!!!{}", param);
let netconfig=MyConfig::get_net_config(cfg,param); let netconfig = MyConfig::get_net_config(cfg, param);
if !netconfig.enabled { if !netconfig.enabled {
debug!("network disabled {}",param); debug!("network disabled {}", param);
return Ok(Response::new(full("network disabled"))); return Ok(Response::new(full("network disabled")));
} }
let address = match netconfig.xpub{ let address = match netconfig.xpub {
false => { false => {
let address = netconfig.address.to_string(); let address = netconfig.address.to_string();
trace!("is address: {}",&address); trace!("is address: {}", &address);
address address
}, }
true => { true => {
let db = sqlite::open(&cfg.db_file).unwrap(); let db = sqlite::open(&cfg.db_file).unwrap();
match get_last_used_address_by_ip(&db,&netconfig.name,&netconfig.address,&remote_addr){ match get_last_used_address_by_ip(
Some(address)=>address, &db,
&netconfig.name,
&netconfig.address,
&remote_addr,
) {
Some(address) => address,
None => { None => {
let next = get_next_address_index(&db,&netconfig.name,&netconfig.address); let next = get_next_address_index(&db, &netconfig.name, &netconfig.address);
let address = new_address_from_xpub(&netconfig.address,next.1,netconfig.network).unwrap(); let address =
save_new_address(&db,next.0,&address.0,&address.1,&remote_addr); new_address_from_xpub(&netconfig.address, next.1, netconfig.network)
debug!("save new address {} {}",address.0,address.1); .unwrap();
trace!("next {} {}",next.0,next.1); save_new_address(&db, next.0, &address.0, &address.1, &remote_addr);
debug!("save new address {} {}", address.0, address.1);
trace!("next {} {}", next.0, next.1);
address.0 address.0
} }
} }
} }
}; };
let info = Info{ let info = Info {
address, address,
base_fee: netconfig.fixed_fee, base_fee: netconfig.fixed_fee,
chain: netconfig.network.to_string(), chain: netconfig.network.to_string(),
info: cfg.info.to_string(), info: cfg.info.to_string(),
version: VERSION.to_string() version: VERSION.to_string(),
}; };
trace!("address: {:#?}",info); trace!("address: {:#?}", info);
match serde_json::to_string(&info){ match serde_json::to_string(&info) {
Ok(json_data) => { Ok(json_data) => {
debug!("echo info reply: {}", json_data); debug!("echo info reply: {}", json_data);
return Ok(Response::new(full(json_data))); return Ok(Response::new(full(json_data)));
},
Err(err) => Ok(Response::new(full(format!("error:{}",err))))
} }
Err(err) => Ok(Response::new(full(format!("error:{}", err)))),
}
} }
async fn echo_search(whole_body: &Bytes, async fn echo_search(
whole_body: &Bytes,
cfg: &MyConfig, cfg: &MyConfig,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
info!("echo search!!!"); info!("echo search!!!");
let strbody = std::str::from_utf8(whole_body).unwrap(); let strbody = std::str::from_utf8(whole_body).unwrap();
info!("{}",strbody); info!("{}", strbody);
let mut response = Response::new(full("Bad data received".to_owned())); let mut response = Response::new(full("Bad data received".to_owned()));
*response.status_mut() = StatusCode::BAD_REQUEST; *response.status_mut() = StatusCode::BAD_REQUEST;
if !strbody.is_empty() && strbody.len()<=70 { if !strbody.is_empty() && strbody.len() <= 70 {
let db = sqlite::open(&cfg.db_file).unwrap(); let db = sqlite::open(&cfg.db_file).unwrap();
let mut statement = db.prepare("SELECT * FROM tbl_tx WHERE txid = ? LIMIT 1").unwrap(); let mut statement = db
.prepare("SELECT * FROM tbl_tx WHERE txid = ? LIMIT 1")
.unwrap();
statement.bind((1, strbody)).unwrap(); statement.bind((1, strbody)).unwrap();
if let Ok(State::Row) = statement.next() { if let Ok(State::Row) = statement.next() {
@@ -232,19 +308,18 @@ async fn echo_search(whole_body: &Bytes,
None None
} }
}; };
response = match serde_json::to_string(&response_data){ response = match serde_json::to_string(&response_data) {
Ok(json_data) => Response::new(full(json_data)), Ok(json_data) => Response::new(full(json_data)),
Err(_) => { response } Err(_) => response,
}; };
return Ok(response); return Ok(response);
} }
} }
Ok(response) Ok(response)
} }
async fn echo_push(whole_body: &Bytes, async fn echo_push(
whole_body: &Bytes,
cfg: &MyConfig, cfg: &MyConfig,
param: &str, param: &str,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
@@ -253,9 +328,9 @@ async fn echo_push(whole_body: &Bytes,
let mut response = Response::new(full("Bad data received".to_owned())); let mut response = Response::new(full("Bad data received".to_owned()));
let mut response_not_enable = Response::new(full("Network not enabled".to_owned())); let mut response_not_enable = Response::new(full("Network not enabled".to_owned()));
*response.status_mut() = StatusCode::BAD_REQUEST; *response.status_mut() = StatusCode::BAD_REQUEST;
*response_not_enable.status_mut()=StatusCode::BAD_REQUEST; *response_not_enable.status_mut() = StatusCode::BAD_REQUEST;
let netconfig = MyConfig::get_net_config(cfg,param); let netconfig = MyConfig::get_net_config(cfg, param);
if !netconfig.enabled{ if !netconfig.enabled {
return Ok(response_not_enable); return Ok(response_not_enable);
} }
let req_time = Utc::now().timestamp_nanos_opt().unwrap(); // Returns i64 let req_time = Utc::now().timestamp_nanos_opt().unwrap(); // Returns i64
@@ -273,75 +348,86 @@ async fn echo_push(whole_body: &Bytes,
let mut union_inps = true; let mut union_inps = true;
let mut union_outs = true; let mut union_outs = true;
let mut already_present = false; let mut already_present = false;
let mut ptx:Vec<(usize, Value)> = vec![]; let mut ptx: Vec<(usize, Value)> = vec![];
let mut pinps:Vec<(usize, Value)> = vec![]; let mut pinps: Vec<(usize, Value)> = vec![];
let mut pouts:Vec<(usize, Value)> = vec![]; let mut pouts: Vec<(usize, Value)> = vec![];
let mut linenum = 1; let mut linenum = 1;
let mut lineinp = 1; let mut lineinp = 1;
let mut lineout = 1; let mut lineout = 1;
for line in lines { for line in lines {
if line.is_empty(){ if line.is_empty() {
trace!("line len is: {}",line.len()); trace!("line len is: {}", line.len());
continue continue;
} }
let linea = format!("{req_time}:{line}"); let linea = format!("{req_time}:{line}");
info!("New Tx: {}", linea); info!("New Tx: {}", linea);
let raw_tx = match Vec::<u8>::from_hex(line) { let raw_tx = match Vec::<u8>::from_hex(line) {
Ok(raw_tx) => raw_tx, Ok(raw_tx) => raw_tx,
Err(err) => { Err(err) => {
error!("rawtx error: {}",err); error!("rawtx error: {}", err);
continue continue;
} }
}; };
if !raw_tx.is_empty(){ if !raw_tx.is_empty() {
trace!("len: {}",raw_tx.len()); trace!("len: {}", raw_tx.len());
let tx: Transaction = match consensus::deserialize(&raw_tx){ let tx: Transaction = match consensus::deserialize(&raw_tx) {
Ok(tx) => tx, Ok(tx) => tx,
Err(err) => {error!("error: unable to parse tx: {}\n{}",line,err);continue} Err(err) => {
error!("error: unable to parse tx: {}\n{}", line, err);
continue;
}
}; };
let txid = tx.compute_txid().to_string(); let txid = tx.compute_txid().to_string();
trace!("txid: {}",txid); trace!("txid: {}", txid);
let mut statement = db.prepare("SELECT * FROM tbl_tx WHERE txid = ?").unwrap(); let mut statement = db.prepare("SELECT * FROM tbl_tx WHERE txid = ?").unwrap();
statement.bind((1,&txid[..])).unwrap(); statement.bind((1, &txid[..])).unwrap();
if let Ok(State::Row) = statement.next() { if let Ok(State::Row) = statement.next() {
trace!("already present"); trace!("already present");
already_present=true; already_present = true;
continue; continue;
} }
let ntxid = tx.compute_ntxid(); let ntxid = tx.compute_ntxid();
let wtxid = tx.compute_wtxid(); let wtxid = tx.compute_wtxid();
let mut found = false; let mut found = false;
let locktime = tx.lock_time; let locktime = tx.lock_time;
let mut our_address:String = "".to_string(); let mut our_address: String = "".to_string();
let mut our_fees:u64 = 0; let mut our_fees: u64 = 0;
for input in tx.input{ for input in tx.input {
if !union_inps { if !union_inps {
sqlinps = format!("{sqlinps} UNION ALL"); sqlinps = format!("{sqlinps} UNION ALL");
}else{ } else {
union_inps = false; union_inps = false;
} }
sqlinps = format!("{sqlinps} SELECT ?, ?, ?"); sqlinps = format!("{sqlinps} SELECT ?, ?, ?");
pinps.push((lineinp,Value::String(txid.to_string()))); pinps.push((lineinp, Value::String(txid.to_string())));
pinps.push((lineinp+1,Value::String(input.previous_output.txid.to_string()))); pinps.push((
pinps.push((lineinp+2,Value::String(input.previous_output.vout.to_string()))); lineinp + 1,
Value::String(input.previous_output.txid.to_string()),
));
pinps.push((
lineinp + 2,
Value::String(input.previous_output.vout.to_string()),
));
lineinp += 3; lineinp += 3;
} }
if netconfig.fixed_fee ==0 { if netconfig.fixed_fee == 0 {
found = true; found = true;
} }
for (idx,output) in tx.output.into_iter().enumerate(){ for (idx, output) in tx.output.into_iter().enumerate() {
let script_pubkey = output.script_pubkey; let script_pubkey = output.script_pubkey;
let address = match bitcoin::Address::from_script(script_pubkey.as_script(), netconfig.network){ let address = match bitcoin::Address::from_script(
script_pubkey.as_script(),
netconfig.network,
) {
Ok(address) => address.to_string(), Ok(address) => address.to_string(),
Err(_) => String::new(), Err(_) => String::new(),
}; };
let amount = output.value; let amount = output.value;
our_fees = netconfig.fixed_fee;//search wllexecutor output our_fees = netconfig.fixed_fee; //search wllexecutor output
if netconfig.xpub{ if netconfig.xpub {
let sql="select * from tbl_address where address=?"; let sql = "select * from tbl_address where address=?";
let mut stmt = db.prepare(sql).expect("failed to fetch addresses"); let mut stmt = db.prepare(sql).expect("failed to fetch addresses");
stmt.bind((1,Value::String(address.to_string()))).unwrap(); stmt.bind((1, Value::String(address.to_string()))).unwrap();
if let Ok(State::Row) = stmt.next() { if let Ok(State::Row) = stmt.next() {
our_address = address.to_string(); our_address = address.to_string();
} }
@@ -352,54 +438,57 @@ async fn echo_push(whole_body: &Bytes,
our_fees = amount.to_sat(); our_fees = amount.to_sat();
our_address = netconfig.address.to_string(); our_address = netconfig.address.to_string();
found = true; found = true;
trace!("address and fees are correct {}: {}",our_address,our_fees); trace!("address and fees are correct {}: {}", our_address, our_fees);
} }
if !union_outs { if !union_outs {
sqlouts = format!("{sqlouts} UNION ALL"); sqlouts = format!("{sqlouts} UNION ALL");
}else{ } else {
union_outs = false; union_outs = false;
} }
sqlouts = format!("{sqlouts} SELECT ?, ?, ?, ?"); sqlouts = format!("{sqlouts} SELECT ?, ?, ?, ?");
pouts.push((lineout,Value::String(txid.to_string()))); pouts.push((lineout, Value::String(txid.to_string())));
pouts.push((lineout+1,Value::Integer(idx.try_into().unwrap()))); pouts.push((lineout + 1, Value::Integer(idx.try_into().unwrap())));
pouts.push((lineout+2,Value::String(script_pubkey.to_string()))); pouts.push((lineout + 2, Value::String(script_pubkey.to_string())));
pouts.push((lineout+3,Value::Integer(amount.to_sat().try_into().unwrap()))); pouts.push((
lineout + 3,
Value::Integer(amount.to_sat().try_into().unwrap()),
));
lineout += 4; lineout += 4;
} }
if !found { if !found {
error!("willexecutor output not found "); error!("willexecutor output not found ");
return Ok(response) return Ok(response);
} else { } else {
if !union_tx { if !union_tx {
sqltxs = format!("{sqltxs} UNION ALL"); sqltxs = format!("{sqltxs} UNION ALL");
}else{ } else {
union_tx = false; union_tx = false;
} }
sqltxs = format!("{sqltxs} SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?"); sqltxs = format!("{sqltxs} SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?");
ptx.push((linenum,Value::String(txid))); ptx.push((linenum, Value::String(txid)));
ptx.push((linenum+1,Value::String(wtxid.to_string()))); ptx.push((linenum + 1, Value::String(wtxid.to_string())));
ptx.push((linenum+2,Value::String(ntxid.to_string()))); ptx.push((linenum + 2, Value::String(ntxid.to_string())));
ptx.push((linenum+3,Value::String(line.to_string()))); ptx.push((linenum + 3, Value::String(line.to_string())));
ptx.push((linenum+4,Value::String(locktime.to_string()))); ptx.push((linenum + 4, Value::String(locktime.to_string())));
ptx.push((linenum+5,Value::String(req_time.to_string()))); ptx.push((linenum + 5, Value::String(req_time.to_string())));
ptx.push((linenum+6,Value::String(netconfig.name.to_string()))); ptx.push((linenum + 6, Value::String(netconfig.name.to_string())));
ptx.push((linenum+7,Value::String(our_address.to_string()))); ptx.push((linenum + 7, Value::String(our_address.to_string())));
ptx.push((linenum+8,Value::String(our_fees.to_string()))); ptx.push((linenum + 8, Value::String(our_fees.to_string())));
linenum += 9; linenum += 9;
} }
}else{ } else {
trace!("rawTx len is: {}",raw_tx.len()); trace!("rawTx len is: {}", raw_tx.len());
debug!("{}",&sqltxs); debug!("{}", &sqltxs);
} }
} }
if sqltxs.is_empty() && already_present { if sqltxs.is_empty() && already_present {
return Ok(Response::new(full("already present"))) return Ok(Response::new(full("already present")));
} }
let sqltxs = format!("{}{};", sqltxshead, sqltxs); let sqltxs = format!("{}{};", sqltxshead, sqltxs);
let sqlinps = format!("{}{};", sqlinpshead, sqlinps); let sqlinps = format!("{}{};", sqlinpshead, sqlinps);
let sqlouts = format!("{}{};", sqloutshead, sqlouts); let sqlouts = format!("{}{};", sqloutshead, sqlouts);
if let Err(err) = execute_insert(&db, sqltxs, ptx, sqlinps, pinps, sqlouts, pouts){ if let Err(err) = execute_insert(&db, sqltxs, ptx, sqlinps, pinps, sqlouts, pouts) {
debug!("{}",err); debug!("{}", err);
return Ok(response); return Ok(response);
} }
Ok(Response::new(full("thx"))) Ok(Response::new(full("thx")))
@@ -415,53 +504,60 @@ fn match_uri<'a>(path: &str, uri: &'a str) -> Option<&'a str> {
None None
} }
async fn echo( async fn echo(
req: Request<hyper::body::Incoming>, req: Request<hyper::body::Incoming>,
cfg: &MyConfig, cfg: &MyConfig,
ip: &String ip: &String,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> { ) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
let mut not_found = Response::new(empty()); let mut not_found = Response::new(empty());
*not_found.status_mut() = StatusCode::NOT_FOUND; *not_found.status_mut() = StatusCode::NOT_FOUND;
let mut ret: Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> = Ok(not_found); let mut ret: Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> = Ok(not_found);
let uri = req.uri().path().to_string(); let uri = req.uri().path().to_string();
let remote_addr = req.headers().get("X-Real-IP").and_then(|value| value.to_str().ok()).and_then(|xff| xff.split(',').next()).map(|ip| ip.trim().to_string()).unwrap_or_else(|| ip.to_string()); let remote_addr = req
trace!("{}: {}",remote_addr,uri); .headers()
.get("X-Real-IP")
.and_then(|value| value.to_str().ok())
.and_then(|xff| xff.split(',').next())
.map(|ip| ip.trim().to_string())
.unwrap_or_else(|| ip.to_string());
trace!("{}: {}", remote_addr, uri);
match *req.method() { match *req.method() {
// Serve some instructions at / // Serve some instructions at /
Method::POST => { Method::POST => {
let whole_body = req.collect().await?.to_bytes(); let whole_body = req.collect().await?.to_bytes();
if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/pushtxs$",uri.as_str()) { if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/pushtxs$", uri.as_str()) {
//let whole_body = collect_body(req,512_000).await?; //let whole_body = collect_body(req,512_000).await?;
ret = echo_push(&whole_body,cfg,param).await; ret = echo_push(&whole_body, cfg, param).await;
} }
if uri=="/searchtx"{ if uri == "/searchtx" {
//let whole_body = collect_body(req,64).await?; //let whole_body = collect_body(req,64).await?;
ret = echo_search(&whole_body,cfg).await; ret = echo_search(&whole_body, cfg).await;
} }
ret ret
} }
Method::GET => { Method::GET => {
if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/info$",uri.as_str()) { if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/stats$", uri.as_str()) {
ret = echo_info(param,cfg,remote_addr).await; ret = echo_stats(param, cfg, &remote_addr).await;
} }
if uri=="/version"{ if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/info$", uri.as_str()) {
ret= echo_version().await; ret = echo_info(param, cfg, &remote_addr).await;
} }
if uri=="/.pub_key.pem" { if uri == "/version" {
ret = echo_version().await;
}
if uri == "/.pub_key.pem" {
ret = echo_pub_key(cfg).await; ret = echo_pub_key(cfg).await;
} }
if uri=="/"{ if uri == "/" {
ret = echo_home(cfg).await; ret = echo_home(cfg).await;
} }
ret ret
} }
// Return the 404 Not Found for other routes. // Return the 404 Not Found for other routes.
_ => ret _ => ret,
} }
} }
@@ -476,113 +572,120 @@ fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
.map_err(|never| match never {}) .map_err(|never| match never {})
.boxed() .boxed()
} }
fn parse_env(cfg: &Arc<Mutex<MyConfig>>){ fn parse_env(cfg: &Arc<Mutex<MyConfig>>) {
for (key, value) in std::env::vars() { for (key, value) in std::env::vars() {
debug!("ENVIRONMENT {key}: {value}"); debug!("ENVIRONMENT {key}: {value}");
} }
let mut cfg_lock = cfg.lock().unwrap(); let mut cfg_lock = cfg.lock().unwrap();
if let Ok(value) = env::var("BAL_SERVER_DB_FILE") { if let Ok(value) = env::var("BAL_SERVER_DB_FILE") {
debug!("BAL_SERVER_DB_FILE: {}",value); debug!("BAL_SERVER_DB_FILE: {}", value);
cfg_lock.db_file = value; cfg_lock.db_file = value;
} }
if let Ok(value) = env::var("BAL_SERVER_BIND_ADDRESS") { if let Ok(value) = env::var("BAL_SERVER_BIND_ADDRESS") {
debug!("BAL_SERVER_BIND_ADDRESS: {}",value); debug!("BAL_SERVER_BIND_ADDRESS: {}", value);
cfg_lock.bind_address= value; cfg_lock.bind_address = value;
} }
if let Ok(value) = env::var("BAL_SERVER_BIND_PORT") { if let Ok(value) = env::var("BAL_SERVER_BIND_PORT") {
debug!("BAL_SERVER_BIND_PORT: {}",value); debug!("BAL_SERVER_BIND_PORT: {}", value);
if let Ok(v) = value.parse::<u16>(){ if let Ok(v) = value.parse::<u16>() {
cfg_lock.bind_port = v; cfg_lock.bind_port = v;
} }
} }
if let Ok(value) = env::var("BAL_SERVER_PUB_KEY_PATH") { if let Ok(value) = env::var("BAL_SERVER_PUB_KEY_PATH") {
debug!("BAL_SERVER_PUB_KEY_PATH: {}",value); debug!("BAL_SERVER_PUB_KEY_PATH: {}", value);
cfg_lock.pub_key_path = value; cfg_lock.pub_key_path = value;
} }
if let Ok(value) = env::var("BAL_SERVER_INFO") {
if let Ok(value) = env::var("BAL_SERVER_INFO"){ debug!("BAL_SERVER_INFO: {}", value);
debug!("BAL_SERVER_INFO: {}",value);
cfg_lock.info = value; cfg_lock.info = value;
} }
cfg_lock = parse_env_netconfig(cfg_lock,"regtest"); cfg_lock = parse_env_netconfig(cfg_lock, "regtest");
cfg_lock = parse_env_netconfig(cfg_lock,"signet"); cfg_lock = parse_env_netconfig(cfg_lock, "signet");
cfg_lock = parse_env_netconfig(cfg_lock,"testnet"); cfg_lock = parse_env_netconfig(cfg_lock, "testnet");
drop(parse_env_netconfig(cfg_lock,"bitcoin")); drop(parse_env_netconfig(cfg_lock, "bitcoin"));
} }
fn parse_env_netconfig<'a>(mut cfg_lock: MutexGuard<'a, MyConfig>, chain: &'a str) -> MutexGuard<'a, MyConfig>{ fn parse_env_netconfig<'a>(
let cfg = match chain{ mut cfg_lock: MutexGuard<'a, MyConfig>,
chain: &'a str,
) -> MutexGuard<'a, MyConfig> {
let cfg = match chain {
"regtest" => &mut cfg_lock.regtest, "regtest" => &mut cfg_lock.regtest,
"signet" => &mut cfg_lock.signet, "signet" => &mut cfg_lock.signet,
"testnet" => &mut cfg_lock.testnet, "testnet" => &mut cfg_lock.testnet,
&_ => &mut cfg_lock.mainnet, &_ => &mut cfg_lock.mainnet,
}; };
if let Ok(value) = env::var(format!("BAL_SERVER_{}_ADDRESS",chain.to_uppercase())) { if let Ok(value) = env::var(format!("BAL_SERVER_{}_ADDRESS", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_ADDRESS: {}",chain.to_uppercase(),value); debug!("BAL_SERVER_{}_ADDRESS: {}", chain.to_uppercase(), value);
cfg.address = value; cfg.address = value;
if cfg.address.len() > 5 { if cfg.address.len() > 5 {
if cfg.address[1..4] == *"pub" { if cfg.address[1..4] == *"pub" {
cfg.xpub=true; cfg.xpub = true;
trace!("is_xpub"); trace!("is_xpub");
} }
cfg.enabled=true; cfg.enabled = true;
} }
} }
if let Ok(value) = env::var(format!("BAL_SERVER_{}_FIXED_FEE",chain.to_uppercase())) { if let Ok(value) = env::var(format!("BAL_SERVER_{}_FIXED_FEE", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_FIXED_FEE: {}",chain.to_uppercase(),value); debug!("BAL_SERVER_{}_FIXED_FEE: {}", chain.to_uppercase(), value);
if let Ok(v) = value.parse::<u64>(){ if let Ok(v) = value.parse::<u64>() {
cfg.fixed_fee = v; cfg.fixed_fee = v;
} }
} }
cfg_lock cfg_lock
} }
fn init_network(db: &Connection, cfg: &MyConfig){ fn init_network(db: &Connection, cfg: &MyConfig) {
for network in NETWORKS{ for network in NETWORKS {
let netconfig = MyConfig::get_net_config(cfg,network); let netconfig = MyConfig::get_net_config(cfg, network);
insert_xpub(db,&netconfig.name,&netconfig.address); insert_xpub(db, &netconfig.name, &netconfig.address);
} }
} }
#[tokio::main] #[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> { async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
env_logger::init(); env_logger::init();
let cfg: Arc<Mutex<MyConfig>> =Arc::<Mutex<MyConfig>>::default(); let cfg: Arc<Mutex<MyConfig>> = Arc::<Mutex<MyConfig>>::default();
parse_env(&cfg); parse_env(&cfg);
let cfg_lock = cfg.lock().unwrap(); let cfg_lock = cfg.lock().unwrap();
let db = sqlite::open(&cfg_lock.db_file).unwrap(); let db = sqlite::open(&cfg_lock.db_file).unwrap();
create_database(&db); create_database(&db);
init_network(&db,&cfg_lock); init_network(&db, &cfg_lock);
let addr = cfg_lock.bind_address.to_string(); let addr = cfg_lock.bind_address.to_string();
let addr: IpAddr = addr.parse()?; let addr: IpAddr = addr.parse()?;
let listener = TcpListener::bind((addr,cfg_lock.bind_port)).await?; let listener = TcpListener::bind((addr, cfg_lock.bind_port)).await?;
info!("Listening on http://{}:{}", addr,cfg_lock.bind_port); info!("Listening on http://{}:{}", addr, cfg_lock.bind_port);
loop { loop {
let (stream, _) = listener.accept().await?; let (stream, _) = listener.accept().await?;
let ip = stream.peer_addr()?.to_string().split(":").next().unwrap().to_string(); let ip = stream
.peer_addr()?
.to_string()
.split(":")
.next()
.unwrap()
.to_string();
let io = TokioIo::new(stream); let io = TokioIo::new(stream);
tokio::task::spawn({ tokio::task::spawn({
let cfg = cfg_lock.clone(); let cfg = cfg_lock.clone();
async move { async move {
if let Err(err) = http1::Builder::new() if let Err(err) = http1::Builder::new()
.serve_connection(io, service_fn(|req: Request<hyper::body::Incoming>| async { .serve_connection(
echo(req,&cfg,&ip).await io,
})) service_fn(|req: Request<hyper::body::Incoming>| async {
echo(req, &cfg, &ip).await
}),
)
.await .await
{ {
error!("Error serving connection: {:?}", err); error!("Error serving connection: {:?}", err);
} }
} }
}); });
} }

142
src/db.rs
View File

@@ -1,7 +1,7 @@
use sqlite::{ Connection, Value, State, Error }; use log::{error, info, trace};
use log::{info, trace, error}; use sqlite::{Connection, Error, State, Value};
pub fn create_database(db: &Connection){ pub fn create_database(db: &Connection) {
info!("database sanity check"); info!("database sanity check");
let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_tx (txid PRIMARY KEY, date_creation TIMESTAMP DEFAULT CURRENT_TIMESTAMP, date_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP, wtxid, ntxid, tx, locktime integer, network, network_fees, reqid, our_fees, our_address, status integer DEFAULT 0);"); let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_tx (txid PRIMARY KEY, date_creation TIMESTAMP DEFAULT CURRENT_TIMESTAMP, date_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP, wtxid, ntxid, tx, locktime integer, network, network_fees, reqid, our_fees, our_address, status integer DEFAULT 0);");
let _ = db.execute("ALTER TABLE tbl_tx ADD COLUMN push_err TEXT"); let _ = db.execute("ALTER TABLE tbl_tx ADD COLUMN push_err TEXT");
@@ -9,17 +9,15 @@ pub fn create_database(db: &Connection){
let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_inp(id, txid, in_txid, in_vout);"); let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_inp(id, txid, in_txid, in_vout);");
let _ = db.execute("CREATE UNIQUE INDEX ON tbl_inp(txid,in_txid,in_vout);"); let _ = db.execute("CREATE UNIQUE INDEX ON tbl_inp(txid,in_txid,in_vout);");
let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_out(id, txid, script_pubkey, amount, vout);"); let _ =
db.execute("CREATE TABLE IF NOT EXISTS tbl_out(id, txid, script_pubkey, amount, vout);");
let _ = db.execute("CREATE UNIQUE INDEX ON tbl_out(txid, script_pubkey, amount, vout);"); let _ = db.execute("CREATE UNIQUE INDEX ON tbl_out(txid, script_pubkey, amount, vout);");
let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_xpub (id INTEGER PRIMARY KEY , network TEXT, xpub TEXT, date_create TIMESTAMP DEFAULT CURRENT_TIMESTAMP,path_idx INTEGER DEFAULT -1);"); let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_xpub (id INTEGER PRIMARY KEY , network TEXT, xpub TEXT, date_create TIMESTAMP DEFAULT CURRENT_TIMESTAMP,path_idx INTEGER DEFAULT -1);");
let _ = db.execute("CREATE UNIQUE INDEX idx_xpub ON tbl_xpub (network, xpub)"); let _ = db.execute("CREATE UNIQUE INDEX idx_xpub ON tbl_xpub (network, xpub)");
let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_address (address TEXT PRIMARY_KEY, path TEXT NOT NULL, date_create TIMESTAMP DEFAULT CURRENT_TIMESTAMP, xpub INTEGER,remote_address TEXT);"); let _ = db.execute("CREATE TABLE IF NOT EXISTS tbl_address (address TEXT PRIMARY_KEY, path TEXT NOT NULL, date_create TIMESTAMP DEFAULT CURRENT_TIMESTAMP, xpub INTEGER,remote_address TEXT);");
let _ = db.execute("UPDATE tbl_tx set network='bitcoin' where network='mainnet');"); let _ = db.execute("UPDATE tbl_tx set network='bitcoin' where network='mainnet');");
} }
/* /*
pub fn get_xpub_id(db: &Connection, network: &String, xpub: &String) -> Option<i64>{ pub fn get_xpub_id(db: &Connection, network: &String, xpub: &String) -> Option<i64>{
@@ -33,76 +31,98 @@ pub fn create_database(db: &Connection){
} }
} }
*/ */
pub fn insert_xpub(db: &Connection, network: &String, xpub: &String){ pub fn insert_xpub(db: &Connection, network: &String, xpub: &String) {
if xpub != "" { if xpub != "" {
trace!("going to insert: {} xpub:{}", network, xpub); trace!("going to insert: {} xpub:{}", network, xpub);
let mut stmt = db.prepare ("INSERT INTO tbl_xpub(network,xpub) VALUES(?, ?);").unwrap(); let mut stmt = db
let _ = stmt.bind((1,Value::String(network.to_string()))).unwrap(); .prepare("INSERT INTO tbl_xpub(network,xpub) VALUES(?, ?);")
let _ = stmt.bind((2,Value::String(xpub.to_string()))).unwrap(); .unwrap();
let _ = stmt.bind((1, Value::String(network.to_string()))).unwrap();
let _ = stmt.bind((2, Value::String(xpub.to_string()))).unwrap();
let _ = stmt.next(); let _ = stmt.next();
} }
} }
pub fn get_last_used_address_by_ip(db: &Connection, network: &String, xpub: &String, address: &String) -> Option<String>{ pub fn get_last_used_address_by_ip(
db: &Connection,
network: &String,
xpub: &String,
address: &String,
) -> Option<String> {
let mut stmt = db.prepare("SELECT tbl_address.address FROM tbl_xpub join tbl_address on(tbl_xpub.id = tbl_address.xpub) where tbl_xpub.network = ? and tbl_address.remote_address = ? and tbl_xpub.xpub = ? ORDER BY tbl_address.date_create DESC LIMIT 1;").unwrap(); let mut stmt = db.prepare("SELECT tbl_address.address FROM tbl_xpub join tbl_address on(tbl_xpub.id = tbl_address.xpub) where tbl_xpub.network = ? and tbl_address.remote_address = ? and tbl_xpub.xpub = ? ORDER BY tbl_address.date_create DESC LIMIT 1;").unwrap();
let _ = stmt.bind((1,Value::String(network.to_string()))); let _ = stmt.bind((1, Value::String(network.to_string())));
let _ = stmt.bind((2,Value::String(address.to_string()))); let _ = stmt.bind((2, Value::String(address.to_string())));
let _ = stmt.bind((3,Value::String(xpub.to_string()))); let _ = stmt.bind((3, Value::String(xpub.to_string())));
if let Ok(State::Row) = stmt.next(){ if let Ok(State::Row) = stmt.next() {
let address = stmt.read::<String,_>("address").unwrap(); let address = stmt.read::<String, _>("address").unwrap();
return Some(address); return Some(address);
}else{ } else {
return None; return None;
} }
} }
pub fn get_next_address_index(db: &Connection, network: &String, xpub: &String) -> (i64,i64){ pub fn get_next_address_index(db: &Connection, network: &String, xpub: &String) -> (i64, i64) {
let mut stmt = db.prepare("UPDATE tbl_xpub SET path_idx = path_idx + 1 WHERE network = ? and xpub= ? RETURNING path_idx,id;").unwrap(); let mut stmt = db.prepare("UPDATE tbl_xpub SET path_idx = path_idx + 1 WHERE network = ? and xpub= ? RETURNING path_idx,id;").unwrap();
stmt.bind((1,Value::String(network.to_string()))).unwrap(); stmt.bind((1, Value::String(network.to_string()))).unwrap();
stmt.bind((2,Value::String(xpub.to_string()))).unwrap(); stmt.bind((2, Value::String(xpub.to_string()))).unwrap();
match stmt.next(){ match stmt.next() {
Ok(State::Row) =>{ Ok(State::Row) => {
let next = stmt.read::<i64,_>("path_idx").unwrap(); let next = stmt.read::<i64, _>("path_idx").unwrap();
let id = stmt.read::<i64,_>("id").unwrap(); let id = stmt.read::<i64, _>("id").unwrap();
return (id,next); return (id, next);
},Err(_)=> { }
return (0,0); Err(_) => {
},Ok(State::Done) =>{ return (0, 0);
return (0,0); }
Ok(State::Done) => {
return (0, 0);
} }
}; };
} }
pub fn save_new_address(db: &Connection,xpub: i64,address: &String, path: &String,remote_addr: &String){ pub fn save_new_address(
let mut stmt = db.prepare("INSERT INTO tbl_address(address,path,xpub,remote_address) VALUES(?,?,?,?);").unwrap(); db: &Connection,
xpub: i64,
address: &String,
path: &String,
remote_addr: &String,
) {
let mut stmt = db
.prepare("INSERT INTO tbl_address(address,path,xpub,remote_address) VALUES(?,?,?,?);")
.unwrap();
stmt.bind((1,Value::String(address.to_string()))).unwrap(); stmt.bind((1, Value::String(address.to_string()))).unwrap();
stmt.bind((2,Value::String(path.to_string()))).unwrap(); stmt.bind((2, Value::String(path.to_string()))).unwrap();
stmt.bind((3,Value::Integer(xpub))).unwrap(); stmt.bind((3, Value::Integer(xpub))).unwrap();
stmt.bind((4,Value::String(remote_addr.to_string()))).unwrap(); stmt.bind((4, Value::String(remote_addr.to_string())))
.unwrap();
let _ = stmt.next(); let _ = stmt.next();
} }
pub fn execute_insert(db: &Connection, pub fn execute_insert(
db: &Connection,
sqltxs: String, sqltxs: String,
ptx: Vec<(usize, Value)>, ptx: Vec<(usize, Value)>,
sqlinp: String, sqlinp: String,
pinp: Vec<(usize, Value)>, pinp: Vec<(usize, Value)>,
sqlout: String, sqlout: String,
pout: Vec<(usize, Value)>) -> Result<(),Error>{ pout: Vec<(usize, Value)>,
) -> Result<(), Error> {
let _ = db.execute("BEGIN TRANSACTION"); let _ = db.execute("BEGIN TRANSACTION");
let mut stmt = db.prepare(sqltxs.as_str()).expect("failed to prepare sqltxs"); let mut stmt = db
if let Err(err) = stmt.bind::<&[(_,Value)]>(&ptx[..]) { .prepare(sqltxs.as_str())
.expect("failed to prepare sqltxs");
if let Err(err) = stmt.bind::<&[(_, Value)]>(&ptx[..]) {
error!("error binding transaction parameters: {}", err); error!("error binding transaction parameters: {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
return Err(err); return Err(err);
} }
if let Err(err) = stmt.next() { if let Err(err) = stmt.next() {
error!("error inserting transactions {}",err); error!("error inserting transactions {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
}else{ } else {
let mut stmt = db.prepare(sqlinp.as_str()).expect("failed to prepare sqlinp"); let mut stmt = db
if let Err(err) = stmt.bind::<&[(_,Value)]>(&pinp[..]) { .prepare(sqlinp.as_str())
.expect("failed to prepare sqlinp");
if let Err(err) = stmt.bind::<&[(_, Value)]>(&pinp[..]) {
error!("error binding inputs parameters {}", err); error!("error binding inputs parameters {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
return Err(err); return Err(err);
@@ -111,10 +131,11 @@ pub fn execute_insert(db: &Connection,
error!("error inserting inputs {}", err); error!("error inserting inputs {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
return Err(err); return Err(err);
} else {
}else{ let mut stmt = db
let mut stmt = db.prepare(sqlout.as_str()).expect("failed to prepare sqlout"); .prepare(sqlout.as_str())
if let Err(err) = stmt.bind::<&[(_,Value)]>(&pout[..]) { .expect("failed to prepare sqlout");
if let Err(err) = stmt.bind::<&[(_, Value)]>(&pout[..]) {
error!("error binding outs parameters {}", err); error!("error binding outs parameters {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
return Err(err); return Err(err);
@@ -123,25 +144,20 @@ pub fn execute_insert(db: &Connection,
error!("error inserting outs {}", err); error!("error inserting outs {}", err);
let _ = db.execute("ROLLBACK"); let _ = db.execute("ROLLBACK");
return Err(err); return Err(err);
} }
} }
} }
let _ = db.execute("COMMIT"); let _ = db.execute("COMMIT");
Ok(()) Ok(())
} }
pub fn get_total_transaction_number(db: Connection, network: &String) -> Result<i64,Error> { 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(); let mut stmt = db
stmt.bind((1,Value::String(network.to_string()))).unwrap(); .prepare("SELECT COUNT(*) as total_number FROM tbl_tx where network = ?;")
match stmt.next(){ .unwrap();
Ok(State::Row)=>{ stmt.bind((1, Value::String(network.to_string()))).unwrap();
Ok(stmt.read::<i64,_>("total_number").unwrap()) match stmt.next() {
}, Ok(State::Row) => Ok(stmt.read::<i64, _>("total_number").unwrap()),
Ok(sqlite::State::Done) => todo!(), Ok(sqlite::State::Done) => todo!(),
Err(err)=>Err(err) Err(err) => Err(err),
} }
} }

42
src/xpub.rs
View File

@@ -1,17 +1,16 @@
use sha2::{Digest, Sha256};
use bitcoin::bip32::Xpub;
use std::str::FromStr;
use bitcoin::bip32::DerivationPath;
use bitcoin::key::Secp256k1;
use bitcoin::Address; use bitcoin::Address;
use bitcoin::Network;
use bitcoin::ScriptBuf; use bitcoin::ScriptBuf;
use bitcoin::WPubkeyHash; use bitcoin::WPubkeyHash;
use bitcoin::Network; use bitcoin::bip32::DerivationPath;
use bitcoin::bip32::Xpub;
use bitcoin::hashes::Hash; use bitcoin::hashes::Hash;
use bitcoin::key::Secp256k1;
use sha2::{Digest, Sha256};
use std::str::FromStr;
// Mainnet (BIP44/BIP49/BIP84) // Mainnet (BIP44/BIP49/BIP84)
enum BS58Prefix{ enum BS58Prefix {
Xpub, Xpub,
//Ypub, //Ypub,
//Zpub, //Zpub,
@@ -19,15 +18,13 @@ enum BS58Prefix{
//Vpub, //Vpub,
//Upub //Upub
} }
const XPUB_PREFIX:[u8; 4] = [0x04, 0x88, 0xB2, 0x1E]; // xpub (Legacy P2PKH) const XPUB_PREFIX: [u8; 4] = [0x04, 0x88, 0xB2, 0x1E]; // xpub (Legacy P2PKH)
//const YPUB_PREFIX:[u8; 4] = [0x04, 0x9D, 0x7C, 0xB2]; // ypub (Nested SegWit P2SH-P2WPKH) //const YPUB_PREFIX:[u8; 4] = [0x04, 0x9D, 0x7C, 0xB2]; // ypub (Nested SegWit P2SH-P2WPKH)
//const ZPUB_PREFIX:[u8; 4] = [0x04, 0xB2, 0x47, 0x46]; // zpub (Native SegWit P2WPKH) //const ZPUB_PREFIX:[u8; 4] = [0x04, 0xB2, 0x47, 0x46]; // zpub (Native SegWit P2WPKH)
//const TPUB_PREFIX:[u8; 4] = [0x04, 0x35, 0x87, 0xCF]; // tpub (Testnet Legacy P2PKH) //const TPUB_PREFIX:[u8; 4] = [0x04, 0x35, 0x87, 0xCF]; // tpub (Testnet Legacy P2PKH)
//const VPUB_PREFIX:[u8; 4] = [0x04, 0x5F, 0x1C, 0xF6]; // vpub (Testnet Nested SegWit) //const VPUB_PREFIX:[u8; 4] = [0x04, 0x5F, 0x1C, 0xF6]; // vpub (Testnet Nested SegWit)
//const UPUB_PREFIX:[u8; 4] = [0x04, 0x4A, 0x52, 0x62]; // upub (RegTest Nested SegWit) //const UPUB_PREFIX:[u8; 4] = [0x04, 0x4A, 0x52, 0x62]; // upub (RegTest Nested SegWit)
fn base58check_decode(s: &str) -> Result<Vec<u8>, String> { fn base58check_decode(s: &str) -> Result<Vec<u8>, String> {
let data = bs58::decode(s).into_vec().map_err(|e| e.to_string())?; let data = bs58::decode(s).into_vec().map_err(|e| e.to_string())?;
if data.len() < 4 { if data.len() < 4 {
@@ -47,27 +44,33 @@ fn base58check_encode(data: &[u8]) -> String {
bs58::encode(full).into_string() bs58::encode(full).into_string()
} }
fn convert_to(zpub: &str,prefix: BS58Prefix) -> Result<String, String> { fn convert_to(zpub: &str, prefix: BS58Prefix) -> Result<String, String> {
let mut data = base58check_decode(zpub)?; let mut data = base58check_decode(zpub)?;
if data.len() < 4 { if data.len() < 4 {
return Err("Non è una zpub valida.".to_string()); return Err("Non è una zpub valida.".to_string());
} }
data.splice(0..4, match prefix { data.splice(
0..4,
match prefix {
BS58Prefix::Xpub => XPUB_PREFIX, BS58Prefix::Xpub => XPUB_PREFIX,
//BS58Prefix::Ypub => YPUB_PREFIX, //BS58Prefix::Ypub => YPUB_PREFIX,
//BS58Prefix::Zpub => ZPUB_PREFIX, //BS58Prefix::Zpub => ZPUB_PREFIX,
//BS58Prefix::Vpub => VPUB_PREFIX, //BS58Prefix::Vpub => VPUB_PREFIX,
//BS58Prefix::Tpub => TPUB_PREFIX, //BS58Prefix::Tpub => TPUB_PREFIX,
//BS58Prefix::Upub => UPUB_PREFIX, //BS58Prefix::Upub => UPUB_PREFIX,
}); },
);
Ok(base58check_encode(&data)) Ok(base58check_encode(&data))
} }
pub fn new_address_from_xpub(zpub: &str, index: i64,network: Network)-> Result<(String,String), Box<dyn std::error::Error>>{ pub fn new_address_from_xpub(
let xpub = Xpub::from_str(&convert_to(zpub,BS58Prefix::Xpub)?)?; zpub: &str,
let path = format!("m/0/{}",index); index: i64,
network: Network,
) -> Result<(String, String), Box<dyn std::error::Error>> {
let xpub = Xpub::from_str(&convert_to(zpub, BS58Prefix::Xpub)?)?;
let path = format!("m/0/{}", index);
let derivation_path = DerivationPath::from_str(path.as_str())?; let derivation_path = DerivationPath::from_str(path.as_str())?;
let secp = Secp256k1::new(); let secp = Secp256k1::new();
let derived_xpub = xpub.derive_pub(&secp, &derivation_path)?; let derived_xpub = xpub.derive_pub(&secp, &derivation_path)?;
@@ -78,8 +81,7 @@ pub fn new_address_from_xpub(zpub: &str, index: i64,network: Network)-> Result<(
//let script_pubkey = ScriptBuf::new_p2sh(&redeem_script.script_hash()); //let script_pubkey = ScriptBuf::new_p2sh(&redeem_script.script_hash());
let address = Address::from_script(&redeem_script, network)?; let address = Address::from_script(&redeem_script, network)?;
//let address = Address::from_script(&script_pubkey, network)?; //let address = Address::from_script(&script_pubkey, network)?;
Ok((address.to_string(),path.to_string())) Ok((address.to_string(), path.to_string()))
} }
/* /*
fn main() -> Result<(), Box<dyn std::error::Error>>{ fn main() -> Result<(), Box<dyn std::error::Error>>{