SAFE21.io/bal-server
1
0
Fork 0
forked from bitcoinafterlife/bal-server
Code Pull Requests Activity

security: fix audit points 5-9 + optimize echo_push/info endpoints

Browse Source 
- Point 5 (SSRF): Add URL validation for WELIST_SERVER_URL (src/validation.rs)
- Point 6 (DB Access): Add DB path validation, symlink check, WAL mode (open_db)
- Point 8 (HTTPS): Extract nginx config, add deployment checklist, bind warnings
- Point 9 (Input Validation): Add NETWORKS check (404 for unknown), txid 64-hex validation
- Optimize echo_push: parse transactions outside DB lock, batch duplicate check, N+1 xpub lookup eliminated via HashSet cache
- Optimize echo_info: derive BIP32 address outside DB lock, minimize lock duration
- Fix echo_stats SQL injection via parameter binding + add idx_stats_chain index
- New regression tests: ssrf_tests, db_path_validation, input_validation_tests
This commit is contained in:
svatantrya
2026-07-16 18:59:30 -04:00
parent 237e62d4be
commit 4fc0790fe7
20 changed files with 2762 additions and 1022 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -20,6 +20,8 @@ use std::str;
use std::{thread, time::Duration};
use zmq::{Context, DEALER, DONTWAIT, Socket};
use bal_server::db::open_db;
use bal_server::validation::is_valid_welist_url;
use base64::{Engine as _, engine::general_purpose};
use openssl::hash::MessageDigest;
use openssl::pkey::PKey;
@@ -74,7 +76,7 @@ struct NetworkParams {
cookie_file: String,
rpc_user: String,
rpc_pass: String,
zmq_listener:String
zmq_listener: String,
}
fn get_network_params(cfg: &MyConfig, network: Network) -> &NetworkParams {
match network {
@@ -235,7 +237,13 @@ async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(
debug!("best block hash: {}", bcinfo.best_block_hash);
let average_time = bcinfo.median_time;
let db = sqlite::open(&cfg.db_file).unwrap();
let db = match open_db(&cfg.db_file) {
Ok(c) => c,
Err(e) => {
error!("Fatal: {}", e);
std::process::exit(1);
}
};
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);";
@@ -321,7 +329,11 @@ async fn main_result(cfg: &MyConfig, network_params: &NetworkParams) -> Result<(
}
async fn calculate_stats(db: &Connection, chain: String) -> Result<(), reqwest::Error> {
// Validate chain to prevent SQL injection via environment variable tampering
if !chain.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') || chain.is_empty() {
if !chain
.chars()
.all(|c| c.is_alphanumeric() || c == '-' || c == '_')
|| chain.is_empty()
{
error!("Invalid chain name: {chain}");
return Ok(());
}
@@ -403,7 +415,13 @@ async fn send_stats_report(
debug!("sending report to welist");
let welist_url = env::var("WELIST_SERVER_URL")
.unwrap_or("https://welist.bitcoin-after.life".to_string());
if !is_valid_welist_url(&welist_url) {
warn!(
"Invalid or unsafe WELIST_SERVER_URL: {}. Skipping stats report.",
welist_url
);
return Ok(());
}
let client = rClient::new();
let url = format!("{}/ping", welist_url);
debug!("welist url: {}", url);
@@ -480,14 +498,15 @@ fn parse_env_netconfig(cfg_lock: &mut MyConfig, chain: &str) -> NetworkParams {
}
match env::var(format!("BAL_PUSHER_{}_PORT", chain.to_uppercase())) {
Ok(value) => match value.parse::<u64>() {
Ok(value) => {
match u16::try_from(value) {
Ok(port) => cfg.port = port,
Err(e) => {
error!("Port value {} exceeds u16 range for chain {}: {}", value, chain, e);
}
Ok(value) => match u16::try_from(value) {
Ok(port) => cfg.port = port,
Err(e) => {
error!(
"Port value {} exceeds u16 range for chain {}: {}",
value, chain, e
);
}
}
},
Err(_) => {}
},
Err(_) => {}
@@ -522,10 +541,13 @@ fn parse_env_netconfig(cfg_lock: &mut MyConfig, chain: &str) -> NetworkParams {
}
Err(_) => {}
}
println!("{}",format!("BAL_PUSHER_{}_ZMQ_HASHBLOCK", chain.to_uppercase()));
println!(
"{}",
format!("BAL_PUSHER_{}_ZMQ_HASHBLOCK", chain.to_uppercase())
);
match env::var(format!("BAL_PUSHER_{}_ZMQ_HASHBLOCK", chain.to_uppercase())) {
Ok(value) => {
println!("value:{}",value);
println!("value:{}", value);
cfg.zmq_listener = value;
}
Err(_) => {}
@@ -640,7 +662,7 @@ async fn main() -> std::io::Result<()> {
}
match socket.set_subscribe(b"") {
Ok(_) => {},
Ok(_) => {}
Err(e) => {
error!("ZMQ subscribe failed: {}, exiting", e);
return Ok(());

922
src/bin/bal-server-actix.rs Normal file
View File

@@ -0,0 +1,922 @@
use actix_governor::{Governor, GovernorConfigBuilder};
use actix_web::middleware;
use actix_web::web::Bytes;
use actix_web::{App, HttpResponse, HttpServer, Responder, web};
use bitcoin::{Network, Transaction, consensus};
use chrono::Utc;
use hex_conservative::FromHex;
use log::{debug, error, info, trace};
use serde::{Deserialize, Serialize};
use serde_json;
use sqlite::State;
use sqlite::{Connection, Value};
use std::collections::{HashMap, HashSet};
use std::env;
use std::fs;
use std::sync::Mutex;
use bal_server::db::{
check_duplicate_txids, create_database, execute_insert, get_all_addresses_by_xpub,
get_last_used_address_by_ip, get_next_address_index, insert_xpub, open_db, save_new_address,
};
use bal_server::xpub::new_address_from_xpub;
const VERSION: &str = env!("CARGO_PKG_VERSION");
const NETWORKS: [&str; 5] = ["bitcoin", "testnet", "testnet4", "signet", "regtest"];
#[derive(Debug, Clone, Serialize, Deserialize)]
struct NetConfig {
address: String,
fixed_fee: u64,
xpub: bool,
network: Network,
name: String,
enabled: bool,
}
impl NetConfig {
fn default_network(name: String, network: Network) -> Self {
NetConfig {
address: "".to_string(),
fixed_fee: 50000,
xpub: false,
name,
network,
enabled: false,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone)]
struct MyConfig {
regtest: NetConfig,
signet: NetConfig,
testnet: NetConfig,
testnet4: NetConfig,
mainnet: NetConfig,
info: String,
bind_address: String,
bind_port: u16,
db_file: String,
pub_key_path: String,
expose_stats: bool,
}
impl Default for MyConfig {
fn default() -> Self {
MyConfig {
regtest: NetConfig::default_network("regtest".to_string(), Network::Regtest),
signet: NetConfig::default_network("signet".to_string(), Network::Signet),
testnet: NetConfig::default_network("testnet".to_string(), Network::Testnet),
testnet4: NetConfig::default_network("testnet4".to_string(), Network::Testnet4),
mainnet: NetConfig::default_network("bitcoin".to_string(), Network::Bitcoin),
bind_address: "127.0.0.1".to_string(),
bind_port: 9137,
db_file: "bal.db".to_string(),
info: "Will Executor Server".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_or(false),
}
}
}
impl MyConfig {
fn get_net_config(&self, param: &str) -> &NetConfig {
match param {
"regtest" => &self.regtest,
"testnet" => &self.testnet,
"testnet4" => &self.testnet4,
"signet" => &self.signet,
_ => &self.mainnet,
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct InfoResponse {
pub address: String,
pub base_fee: u64,
pub chain: String,
pub info: String,
pub version: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct StatsResponse {
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,
}
#[derive(Debug, Clone)]
struct ActixConfig {
max_body_size: usize,
timeout_secs: u64,
rate_limit_pushtxs: (u64, u32),
rate_limit_searchtx: (u64, u32),
rate_limit_info: (u64, u32),
rate_limit_default: (u64, u32),
workers: usize,
max_connections: usize,
}
fn parse_actix_config() -> ActixConfig {
ActixConfig {
max_body_size: env::var("BAL_SERVER_ACTIX_MAX_BODY_SIZE")
.unwrap_or("1048576".to_string())
.parse::<usize>()
.unwrap_or(1_048_576),
timeout_secs: env::var("BAL_SERVER_ACTIX_TIMEOUT_SECS")
.unwrap_or("5".to_string())
.parse::<u64>()
.unwrap_or(5),
rate_limit_pushtxs: (
env::var("BAL_SERVER_ACTIX_PUSHTXS_PER_SEC")
.unwrap_or("1".to_string())
.parse::<u64>()
.unwrap_or(1),
env::var("BAL_SERVER_ACTIX_PUSHTXS_BURST")
.unwrap_or("3".to_string())
.parse::<u32>()
.unwrap_or(3),
),
rate_limit_searchtx: (
env::var("BAL_SERVER_ACTIX_SEARCHTX_PER_SEC")
.unwrap_or("5".to_string())
.parse::<u64>()
.unwrap_or(5),
env::var("BAL_SERVER_ACTIX_SEARCHTX_BURST")
.unwrap_or("10".to_string())
.parse::<u32>()
.unwrap_or(10),
),
rate_limit_info: (
env::var("BAL_SERVER_ACTIX_INFO_PER_SEC")
.unwrap_or("20".to_string())
.parse::<u64>()
.unwrap_or(20),
env::var("BAL_SERVER_ACTIX_INFO_BURST")
.unwrap_or("30".to_string())
.parse::<u32>()
.unwrap_or(30),
),
rate_limit_default: (
env::var("BAL_SERVER_ACTIX_DEFAULT_PER_SEC")
.unwrap_or("50".to_string())
.parse::<u64>()
.unwrap_or(50),
env::var("BAL_SERVER_ACTIX_DEFAULT_BURST")
.unwrap_or("100".to_string())
.parse::<u32>()
.unwrap_or(100),
),
workers: env::var("BAL_SERVER_ACTIX_WORKERS")
.unwrap_or("4".to_string())
.parse::<usize>()
.unwrap_or(4),
max_connections: env::var("BAL_SERVER_ACTIX_MAX_CONNECTIONS")
.unwrap_or("100".to_string())
.parse::<usize>()
.unwrap_or(100),
}
}
struct AppState {
db: Mutex<Connection>,
cfg: MyConfig,
}
async fn echo_home(data: web::Data<AppState>) -> impl Responder {
HttpResponse::Ok().body(data.cfg.info.clone())
}
async fn echo_pub_key(data: web::Data<AppState>) -> impl Responder {
match fs::read_to_string(&data.cfg.pub_key_path) {
Ok(pub_key) => HttpResponse::Ok().body(pub_key),
Err(e) => {
error!(
"Failed to read public key file {}: {}",
data.cfg.pub_key_path, e
);
HttpResponse::InternalServerError().body("Failed to read public key file")
}
}
}
async fn echo_version() -> impl Responder {
HttpResponse::Ok().body(VERSION)
}
async fn echo_info(
path: web::Path<String>,
data: web::Data<AppState>,
req: actix_web::HttpRequest,
) -> impl Responder {
let param = path.into_inner();
if !NETWORKS.contains(&param.as_str()) {
return HttpResponse::NotFound().body("Unknown network");
}
info!("echo info!!!{}", param);
let netconfig = data.cfg.get_net_config(&param);
if !netconfig.enabled {
debug!("network disabled {}", param);
return HttpResponse::BadRequest().body("network disabled");
}
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(|| {
req.connection_info()
.peer_addr()
.unwrap_or("unknown")
.to_string()
});
let address = match netconfig.xpub {
false => {
let address = netconfig.address.to_string();
trace!("is address: {}", &address);
address
}
true => {
// Lock #1: fetch existing address OR atomically claim next index
let next_idx = {
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_info (lookup phase)");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
match get_last_used_address_by_ip(
&db,
&netconfig.name,
&netconfig.address,
&remote_addr,
) {
Some(address) => return HttpResponse::Ok().json(InfoResponse {
address,
base_fee: netconfig.fixed_fee,
chain: netconfig.network.to_string(),
info: data.cfg.info.to_string(),
version: VERSION.to_string(),
}),
None => {
let next = get_next_address_index(&db, &netconfig.name, &netconfig.address);
next
}
}
}; // lock released
// Derive address (CPU-bound, no lock held)
let derived = match new_address_from_xpub(
&netconfig.address, next_idx.1, netconfig.network
) {
Ok(address) => address,
Err(e) => {
error!("Failed to derive address from xpub: {}", e);
return HttpResponse::BadRequest()
.body(format!("Failed to derive address: {}", e));
}
};
// Lock #2: save the newly derived address
{
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_info (save phase)");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
save_new_address(&db, next_idx.0, &derived.0, &derived.1, &remote_addr);
debug!("save new address {} {}", derived.0, derived.1);
trace!("next {} {}", next_idx.0, next_idx.1);
derived.0
} // lock released
}
};
let info = InfoResponse {
address,
base_fee: netconfig.fixed_fee,
chain: netconfig.network.to_string(),
info: data.cfg.info.to_string(),
version: VERSION.to_string(),
};
trace!("address: {:#?}", info);
match serde_json::to_string(&info) {
Ok(json_data) => {
debug!("echo info reply: {}", json_data);
HttpResponse::Ok().json(info)
}
Err(err) => HttpResponse::InternalServerError().body(format!("error:{}", err)),
}
}
async fn echo_stats(path: web::Path<String>, data: web::Data<AppState>) -> impl Responder {
let param = path.into_inner();
if !NETWORKS.contains(&param.as_str()) {
return HttpResponse::NotFound().body("Unknown network");
}
info!("echo stats!!! {}", data.cfg.expose_stats);
let netconfig = data.cfg.get_net_config(&param);
if !netconfig.enabled {
debug!("network disabled {}", param);
return HttpResponse::BadRequest().body("network disabled");
}
if !data.cfg.expose_stats {
return HttpResponse::Forbidden().body("Stats not exposed");
}
let mut stats: Vec<StatsResponse> = vec![];
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_stats");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
let mut stmt = match db.prepare(
"SELECT report_date, chain, totals, waiting, sent, failed, waiting_profit, sent_profit, missed_profit, unique_inputs FROM tbl_stats WHERE chain = ?"
) {
Ok(s) => s,
Err(e) => {
error!("Failed to prepare stats query: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
};
if let Err(e) = stmt.bind((1, Value::String(netconfig.name.clone()))) {
error!("Failed to bind chain in stats query: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
while let Ok(State::Row) = stmt.next() {
let report_date = stmt.read("report_date").unwrap_or("0".to_string());
let chain = stmt.read("chain").unwrap_or("?".to_string());
let totals = stmt.read("totals").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let waiting = stmt.read("waiting").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let sent = stmt.read("sent").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let failed = stmt.read("failed").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let waiting_profit = stmt.read("waiting_profit").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let sent_profit = stmt.read("sent_profit").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let missed_profit = stmt.read("missed_profit").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
let unique_inputs = stmt.read("unique_inputs").unwrap_or("0".to_string()).parse::<i64>().unwrap_or(0);
stats.push(StatsResponse {
report_date,
chain,
totals,
waiting,
sent,
failed,
waiting_profit,
sent_profit,
missed_profit,
unique_inputs,
});
}
match serde_json::to_string(&stats) {
Ok(json_data) => {
debug!("echo info reply: {}", json_data);
HttpResponse::Ok().json(stats)
}
Err(err) => HttpResponse::InternalServerError().body(format!("error:{}", err)),
}
}
async fn echo_search(body: Bytes, data: web::Data<AppState>) -> impl Responder {
info!("echo search!!!");
let strbody = match std::str::from_utf8(&body) {
Ok(s) => s,
Err(_) => {
return HttpResponse::BadRequest().body("Invalid UTF-8 body");
}
};
info!("{}", strbody);
if strbody.is_empty() || strbody.len() != 64 || !strbody.chars().all(|c| c.is_ascii_hexdigit()) {
return HttpResponse::BadRequest().body("Invalid txid");
}
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_search");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
let mut statement = match db.prepare("SELECT * FROM tbl_tx WHERE txid = ? LIMIT 1") {
Ok(s) => s,
Err(e) => {
error!("Failed to prepare statement: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
};
if let Err(e) = statement.bind((1, strbody)) {
error!("Failed to bind parameter: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
if let Ok(State::Row) = statement.next() {
let mut response_data = HashMap::new();
match statement.read::<String, _>("status") {
Ok(value) => {
response_data.insert("status", value);
}
Err(e) => {
error!("Error reading status: {}", e);
}
}
match statement.read::<String, _>("tx") {
Ok(value) => {
response_data.insert("tx", value);
}
Err(e) => {
error!("Error reading tx: {}", e);
}
}
match statement.read::<String, _>("our_address") {
Ok(value) => {
response_data.insert("our_address", value);
}
Err(e) => {
error!("Error reading address: {}", e);
}
}
match statement.read::<String, _>("our_fees") {
Ok(value) => {
response_data.insert("our_fees", value);
}
Err(e) => {
error!("Error reading fees: {}", e);
}
}
match statement.read::<String, _>("reqid") {
Ok(value) => {
response_data.insert("time", value);
}
Err(e) => {
error!("Error reading reqid: {}", e);
}
}
match serde_json::to_string(&response_data) {
Ok(json_data) => HttpResponse::Ok().json(json_data),
Err(_) => HttpResponse::BadRequest().body("Bad data received"),
}
} else {
HttpResponse::BadRequest().body("Bad data received")
}
}
/// Holds a transaction that has already been parsed and validated outside the DB lock.
#[derive(Clone)]
struct ParsedTx {
txid: String,
wtxid: String,
ntxid: String,
raw_hex: String, // the original line
locktime: String,
inputs: Vec<(String, String)>, // (in_txid, in_vout)
outputs: Vec<(usize, String, u64)> // (idx, script_pubkey, amount_sat)
}
/// Parse all transactions from the request body **without** needing the DB lock.
/// Returns `Ok(parsed_txs)` if at least one tx was valid, or `Err(HttpResponse)` for early failure.
fn parse_request_transactions(
strbody: &str,
_req_time: i64,
netconfig: &NetConfig,
known_addresses: &HashSet<String>,
) -> Result<Vec<(ParsedTx, String, u64)>, HttpResponse> {
let mut result: Vec<(ParsedTx, String, u64)> = Vec::new();
let mut union_tx = true;
for line in strbody.split('\n') {
if line.is_empty() {
continue;
}
let raw_hex = line.to_string();
let raw_tx = match Vec::<u8>::from_hex(line) {
Ok(v) => v,
Err(e) => {
error!("rawtx error: {} for line {}", e, line);
continue;
}
};
if raw_tx.is_empty() {
continue;
}
let tx: Transaction = match consensus::deserialize(&raw_tx) {
Ok(t) => t,
Err(e) => {
error!("Deserialize error: {} for line {}", e, line);
continue;
}
};
let txid = tx.compute_txid().to_string();
let ntxid = tx.compute_ntxid();
let wtxid = tx.compute_wtxid();
let locktime = tx.lock_time.to_string();
// Collect inputs
let mut inputs: Vec<(String, String)> = Vec::with_capacity(tx.input.len());
for input in tx.input {
inputs.push((
input.previous_output.txid.to_string(),
input.previous_output.vout.to_string(),
));
}
// Collect outputs and find which one is ours + its amount
let mut outputs: Vec<(usize, String, u64)> = Vec::with_capacity(tx.output.len());
let mut found = false;
let mut our_address = String::new();
let mut our_fees = 0u64;
for (idx, output) in tx.output.into_iter().enumerate() {
let script = output.script_pubkey.to_string();
let amount = output.value.to_sat();
outputs.push((idx, script.clone(), amount));
let address = match bitcoin::Address::from_script(
output.script_pubkey.as_script(),
netconfig.network,
) {
Ok(addr) => addr.to_string(),
Err(_) => continue, // skip un-decodable outputs
};
let expected_ours = if netconfig.xpub {
if known_addresses.contains(&address) {
address.clone()
} else {
continue
}
} else {
netconfig.address.clone()
};
if address == expected_ours && amount >= netconfig.fixed_fee {
our_address = expected_ours;
our_fees = amount;
found = true;
trace!("address and fees are correct {}: {}", our_address, our_fees);
}
}
if netconfig.fixed_fee == 0 {
found = true;
}
if !found {
error!("willexecutor output not found for tx {}", txid);
return Err(HttpResponse::BadRequest().body("Bad data received"));
}
if !union_tx {
// This is only used for SQL building later; we track it in the caller
} else {
union_tx = false;
}
result.push((
ParsedTx {
txid,
wtxid: wtxid.to_string(),
ntxid: ntxid.to_string(),
raw_hex,
locktime,
inputs,
outputs,
},
our_address,
our_fees,
));
}
Ok(result)
}
async fn echo_push(
body: Bytes,
path: web::Path<String>,
data: web::Data<AppState>,
) -> HttpResponse {
trace!("echo_push");
let strbody = match std::str::from_utf8(&body) {
Ok(s) => s,
Err(_) => {
return HttpResponse::BadRequest().body("Invalid UTF-8 body");
}
};
let param = path.into_inner();
if !NETWORKS.contains(&param.as_str()) {
return HttpResponse::NotFound().body("Unknown network");
}
let netconfig = data.cfg.get_net_config(&param);
if !netconfig.enabled {
trace!("network not enabled {}", &netconfig.name);
return HttpResponse::BadRequest().body("Network not enabled");
}
let req_time = match Utc::now().timestamp_nanos_opt() {
Some(t) => t,
None => {
error!("Invalid timestamp");
return HttpResponse::BadRequest().body("Invalid timestamp");
}
};
// ===== PHASE 1: parse all transactions WITHOUT the DB lock =====
let known_addresses: HashSet<String> = {
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned acquiring addresses in echo_push");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
if netconfig.xpub {
match get_all_addresses_by_xpub(&db, &netconfig.address) {
Ok(addrs) => addrs,
Err(e) => {
error!("Failed to load addresses from xpub: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
}
} else {
HashSet::new()
}
}; // lock released here
// Parse all transactions (CPU-bound, no DB needed)
let parsed = match parse_request_transactions(
strbody, req_time, netconfig, &known_addresses,
) {
Ok(v) => v,
Err(resp) => return resp,
};
if parsed.is_empty() {
return HttpResponse::Ok().body("thx");
}
let all_txids: Vec<String> = parsed.iter().map(|(p, _, _)| p.txid.clone()).collect();
// ===== PHASE 2: check duplicates in a single batch query =====
let duplicates = {
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_push duplicate check");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
match check_duplicate_txids(&db, &all_txids) {
Ok(dups) => dups,
Err(e) => {
error!("Duplicate check failed: {}", e);
return HttpResponse::InternalServerError().body("Database error");
}
}
}; // lock released here
let all_present = all_txids.iter().all(|t| duplicates.contains(t));
if all_present {
return HttpResponse::Ok().body("already present");
}
// ===== PHASE 3: build insert statements and execute (single DB lock, minimal time) =====
{
let db = match data.db.lock() {
Ok(g) => g,
Err(_p) => {
error!("DB mutex poisoned in echo_push insert phase");
return HttpResponse::InternalServerError().body("DB mutex poisoned");
}
};
let sqltxshead = "INSERT INTO tbl_tx (txid, wtxid, ntxid, tx, locktime, reqid, network, our_address, our_fees)".to_string();
let mut sqltxs = String::new();
let sqlinpshead = "INSERT INTO tbl_inp (txid, in_txid, in_vout )".to_string();
let mut sqlinps = String::new();
let sqloutshead = "INSERT INTO tbl_out (txid, vout, script_pubkey, amount )".to_string();
let mut sqlouts = String::new();
let mut union_tx = true;
let mut union_inps = true;
let mut union_outs = true;
let mut ptx: Vec<(usize, Value)> = vec![];
let mut pinps: Vec<(usize, Value)> = vec![];
let mut pouts: Vec<(usize, Value)> = vec![];
let mut linenum = 1usize;
let mut lineinp = 1usize;
let mut lineout = 1usize;
for (parsed, our_address, our_fees) in &parsed {
if duplicates.contains(&parsed.txid) {
continue;
}
if !union_tx {
sqltxs.push_str(" UNION ALL");
} else {
union_tx = false;
}
sqltxs.push_str(" SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?");
ptx.push((linenum, Value::String(parsed.txid.clone())));
ptx.push((linenum + 1, Value::String(parsed.wtxid.clone())));
ptx.push((linenum + 2, Value::String(parsed.ntxid.clone())));
ptx.push((linenum + 3, Value::String(parsed.raw_hex.clone())));
ptx.push((linenum + 4, Value::String(parsed.locktime.clone())));
ptx.push((linenum + 5, Value::String(req_time.to_string())));
ptx.push((linenum + 6, Value::String(netconfig.name.clone())));
ptx.push((linenum + 7, Value::String(our_address.clone())));
ptx.push((linenum + 8, Value::String(our_fees.to_string())));
linenum += 9;
for (in_txid, in_vout) in &parsed.inputs {
if !union_inps {
sqlinps.push_str(" UNION ALL");
} else {
union_inps = false;
}
sqlinps.push_str(" SELECT ?, ?, ?");
pinps.push((lineinp, Value::String(parsed.txid.clone())));
pinps.push((lineinp + 1, Value::String(in_txid.clone())));
pinps.push((lineinp + 2, Value::String(in_vout.clone())));
lineinp += 3;
}
for (idx, script, amount) in &parsed.outputs {
if !union_outs {
sqlouts.push_str(" UNION ALL");
} else {
union_outs = false;
}
sqlouts.push_str(" SELECT ?, ?, ?, ?");
pouts.push((lineout, Value::String(parsed.txid.clone())));
pouts.push((lineout + 1, Value::Integer(i64::try_from(*idx).unwrap_or(-1))));
pouts.push((lineout + 2, Value::String(script.clone())));
pouts.push((lineout + 3, Value::Integer(i64::try_from(*amount).unwrap_or(0))));
lineout += 4;
}
}
if sqltxs.is_empty() {
return HttpResponse::Ok().body("already present");
}
let sqltxs = format!("{}{};", sqltxshead, sqltxs);
let sqlinps = format!("{}{};", sqlinpshead, sqlinps);
let sqlouts = format!("{}{};", sqloutshead, sqlouts);
if let Err(err) = execute_insert(&db, sqltxs, ptx, sqlinps, pinps, sqlouts, pouts) {
error!("execute_insert failed: {}", err);
return HttpResponse::BadRequest().body("Bad data received");
}
} // lock released
HttpResponse::Ok().body("thx")
}
fn parse_env(data: &MyConfig) -> MyConfig {
let mut cfg = data.clone();
if let Ok(value) = env::var("BAL_SERVER_DB_FILE") {
debug!("BAL_SERVER_DB_FILE: {}", value);
cfg.db_file = value;
}
if let Ok(value) = env::var("BAL_SERVER_BIND_ADDRESS") {
debug!("BAL_SERVER_BIND_ADDRESS: {}", value);
cfg.bind_address = value;
}
if let Ok(value) = env::var("BAL_SERVER_BIND_PORT") {
debug!("BAL_SERVER_BIND_PORT: {}", value);
if let Ok(v) = value.parse::<u16>() {
cfg.bind_port = v;
}
}
if let Ok(value) = env::var("BAL_SERVER_PUB_KEY_PATH") {
debug!("BAL_SERVER_PUB_KEY_PATH: {}", value);
cfg.pub_key_path = value;
}
if let Ok(value) = env::var("BAL_SERVER_INFO") {
debug!("BAL_SERVER_INFO: {}", value);
cfg.info = value;
}
parse_env_netconfig(&mut cfg, "regtest");
parse_env_netconfig(&mut cfg, "signet");
parse_env_netconfig(&mut cfg, "testnet");
parse_env_netconfig(&mut cfg, "testnet4");
parse_env_netconfig(&mut cfg, "bitcoin");
cfg
}
fn parse_env_netconfig(cfg: &mut MyConfig, chain: &str) {
let c = match chain {
"regtest" => &mut cfg.regtest,
"signet" => &mut cfg.signet,
"testnet" => &mut cfg.testnet,
"testnet4" => &mut cfg.testnet4,
_ => &mut cfg.mainnet,
};
if let Ok(value) = env::var(format!("BAL_SERVER_{}_ADDRESS", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_ADDRESS: {}", chain.to_uppercase(), value);
c.address = value;
if c.address.len() > 5 && &c.address[1..4] == "pub" {
c.xpub = true;
trace!("is_xpub");
}
c.enabled = true;
}
if let Ok(value) = env::var(format!("BAL_SERVER_{}_FIXED_FEE", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_FIXED_FEE: {}", chain.to_uppercase(), value);
if let Ok(v) = value.parse::<u64>() {
c.fixed_fee = v;
}
}
}
fn init_network(db: &Connection, cfg: &MyConfig) {
for network in NETWORKS {
let netconfig = cfg.get_net_config(network);
insert_xpub(db, &netconfig.name.to_string(), &netconfig.address);
}
}
#[actix_web::main]
async fn main() -> std::io::Result<()> {
env_logger::init();
let cfg = MyConfig::default();
let actix_cfg = parse_actix_config();
let cfg = parse_env(&cfg);
let db = match open_db(&cfg.db_file) {
Ok(c) => c,
Err(e) => {
return Err(std::io::Error::new(std::io::ErrorKind::Other, e));
}
};
// Create database tables
create_database(&db);
// Initialize networks
init_network(&db, &cfg);
let data = web::Data::new(AppState {
db: Mutex::new(db),
cfg: cfg.clone(),
});
// Initialize networks
{
let db = data.db.lock().unwrap();
for network in NETWORKS {
let netconfig = data.cfg.get_net_config(network);
insert_xpub(&db, &netconfig.name.to_string(), &netconfig.address);
}
}
let bind_address = data.cfg.bind_address.clone();
let bind_port = data.cfg.bind_port;
// Use a single global rate limiter with the most conservative settings (1 req/sec)
// Per-endpoint rate limiting requires advanced configuration with explicit types
let governor_conf = GovernorConfigBuilder::const_default()
.seconds_per_request(actix_cfg.rate_limit_pushtxs.0) // Most restrictive: 1 req/sec
.burst_size(actix_cfg.rate_limit_pushtxs.1) // Burst: 3
.finish()
.unwrap();
println!("Starting server on http://{}:{}", bind_address, bind_port);
HttpServer::new(move || {
App::new()
.app_data(web::PayloadConfig::default().limit(actix_cfg.max_body_size))
.app_data(data.clone())
.wrap(middleware::Logger::default())
.wrap(middleware::Compress::default())
.wrap(Governor::new(&governor_conf))
.service(web::resource("/").route(web::get().to(echo_home)))
.service(web::resource("/.pub_key.pem").route(web::get().to(echo_pub_key)))
.service(web::resource("/version").route(web::get().to(echo_version)))
.service(web::resource("/{network}/info").route(web::get().to(echo_info)))
.service(web::resource("/{network}/stats").route(web::get().to(echo_stats)))
.service(web::resource("/{network}/pushtxs").route(web::post().to(echo_push)))
.service(web::resource("/searchtx").route(web::post().to(echo_search)))
})
.workers(actix_cfg.workers)
.max_connections(actix_cfg.max_connections)
.bind((bind_address, bind_port))?
.run()
.await
}

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

@@ -1,792 +0,0 @@
use bytes::Bytes;
use http_body_util::{BodyExt, Empty, Full, combinators::BoxBody};
use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Method, Request, Response, StatusCode};
use hyper_util::rt::TokioIo;
use tokio::net::TcpListener;
use std::env;
use std::net::IpAddr;
//use std::time::{SystemTime,UNIX_EPOCH};
use std::fs;
use std::sync::{Arc, Mutex, MutexGuard};
//use std::net::SocketAddr;
use sqlite::{Connection, State, Value};
use std::collections::HashMap;
use bitcoin::{Network, Transaction, consensus};
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, 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;
const VERSION: &str = env!("CARGO_PKG_VERSION");
const NETWORKS: [&str; 5] = ["bitcoin", "testnet", "testnet4", "signet", "regtest"];
#[derive(Debug, Clone, Serialize, Deserialize)]
struct NetConfig {
address: String,
fixed_fee: u64,
xpub: bool,
network: Network,
name: String,
enabled: bool,
}
impl NetConfig {
fn default_network(name: String, network: Network) -> Self {
NetConfig {
address: "".to_string(),
fixed_fee: 50000,
xpub: false,
name,
network,
enabled: false,
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone)]
struct MyConfig {
regtest: NetConfig,
signet: NetConfig,
testnet: NetConfig,
testnet4: NetConfig,
mainnet: NetConfig,
info: String,
bind_address: String,
bind_port: u16, // Changed to u16 for port numbers
db_file: String,
pub_key_path: String,
expose_stats: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct InfoResponse {
pub address: String,
pub base_fee: u64,
pub chain: String,
pub info: String,
pub version: String,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct StatsResponse {
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 {
fn default() -> Self {
MyConfig {
regtest: NetConfig::default_network("regtest".to_string(), Network::Regtest),
signet: NetConfig::default_network("signet".to_string(), Network::Signet),
testnet: NetConfig::default_network("testnet".to_string(), Network::Testnet),
testnet4: NetConfig::default_network("testnet4".to_string(), Network::Testnet4),
mainnet: NetConfig::default_network("bitcoin".to_string(), Network::Bitcoin),
bind_address: "127.0.0.1".to_string(),
bind_port: 9137,
db_file: "bal.db".to_string(),
info: "Will Executor Server".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 {
fn get_net_config(&self, param: &str) -> &NetConfig {
match param {
"regtest" => &self.regtest,
"testnet" => &self.testnet,
"testnet4" => &self.testnet4,
"signet" => &self.signet,
_ => &self.mainnet,
}
}
}
async fn echo_version() -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
Ok(Response::new(full(VERSION)))
}
async fn echo_home(cfg: &MyConfig) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
debug!("echo_home: {}", cfg.info);
Ok(Response::new(full(cfg.info.clone())))
}
async fn echo_pub_key(
cfg: &MyConfig,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
let pub_key = match fs::read_to_string(&cfg.pub_key_path) {
Ok(s) => s,
Err(e) => {
error!("Failed to read public key file {}: {}", cfg.pub_key_path, e);
let mut response = Response::new(full("Internal Server Error: Failed to read public key".to_owned()));
*response.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
return Ok(response);
}
};
Ok(Response::new(full(pub_key)))
}
async fn echo_stats(
param: &str,
cfg: &MyConfig,
db: &Arc<Mutex<Connection>>,
) -> 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<StatsResponse> = vec![];
let db = match db.lock() {
Ok(g) => g,
Err(p) => {
error!("DB mutex poisoned in echo_stats");
p.into_inner()
}
};
let _ = 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_or("0"));
dbg!(&row);
stats.push(StatsResponse {
report_date: row["report_date"].clone().unwrap_or("0").to_string(),
chain: row["chain"].clone().unwrap_or("?").to_string(),
totals: row["totals"].clone().unwrap_or("0").parse::<i64>().unwrap_or(0),
waiting: row["waiting"].clone().unwrap_or("0").parse::<i64>().unwrap_or(0),
sent: row["sent"].clone().unwrap_or("0").parse::<i64>().unwrap_or(0),
failed: row["failed"].clone().unwrap_or("0").parse::<i64>().unwrap_or(0),
waiting_profit: row["waiting_profit"]
.clone()
.unwrap_or("0")
.parse::<i64>()
.unwrap_or(0),
sent_profit: row["sent_profit"].clone().unwrap_or("0").parse::<i64>().unwrap_or(0),
missed_profit: row["missed_profit"]
.clone()
.unwrap_or("0")
.parse::<i64>()
.unwrap_or(0),
unique_inputs: row["unique_inputs"]
.clone()
.unwrap_or("0")
.parse::<i64>()
.unwrap_or(0),
});
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(
param: &str,
cfg: &MyConfig,
remote_addr: &String,
db: &Arc<Mutex<Connection>>,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
info!("echo info!!!{}", param);
let netconfig = MyConfig::get_net_config(cfg, param);
if !netconfig.enabled {
debug!("network disabled {}", param);
return Ok(Response::new(full("network disabled")));
}
let address = match netconfig.xpub {
false => {
let address = netconfig.address.to_string();
trace!("is address: {}", &address);
address
}
true => {
let db = match db.lock() {
Ok(g) => g,
Err(p) => {
error!("DB mutex poisoned in echo_info");
p.into_inner()
}
};
match get_last_used_address_by_ip(
&db,
&netconfig.name,
&netconfig.address,
&remote_addr,
) {
Some(address) => address,
None => {
let next = get_next_address_index(&db, &netconfig.name, &netconfig.address);
match new_address_from_xpub(&netconfig.address, next.1, netconfig.network) {
Ok(address) => {
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
}
Err(e) => {
error!("Failed to derive address from xpub: {}", e);
// Return error response to the client
let mut response = Response::new(full(format!("Failed to derive address: {}", e)));
*response.status_mut() = StatusCode::BAD_REQUEST;
return Ok(response);
}
}
}
}
}
};
let info = InfoResponse {
address,
base_fee: netconfig.fixed_fee,
chain: netconfig.network.to_string(),
info: cfg.info.to_string(),
version: VERSION.to_string(),
};
trace!("address: {:#?}", info);
match serde_json::to_string(&info) {
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_search(
whole_body: &Bytes,
cfg: &MyConfig,
db: &Arc<Mutex<Connection>>,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
info!("echo search!!!");
let strbody = match std::str::from_utf8(whole_body) {
Ok(s) => s,
Err(_) => {
return Ok(Response::new(full("Invalid UTF-8 body")));
}
};
info!("{}", strbody);
let mut response = Response::new(full("Bad data received".to_owned()));
*response.status_mut() = StatusCode::BAD_REQUEST;
if !strbody.is_empty() && strbody.len() <= 70 {
let db = match db.lock() {
Ok(g) => g,
Err(p) => {
error!("DB mutex poisoned in echo_search");
p.into_inner()
}
};
let mut statement = db
.prepare("SELECT * FROM tbl_tx WHERE txid = ? LIMIT 1")
.unwrap();
statement.bind((1, strbody)).unwrap();
if let Ok(State::Row) = statement.next() {
let mut response_data = HashMap::new();
match statement.read::<String, _>("status") {
Ok(value) => response_data.insert("status", value),
Err(e) => {
error!("Error reading status: {}", e);
//response_data.insert("status", "Error".to_string())
None
}
};
// Read the transaction (tx)
match statement.read::<String, _>("tx") {
Ok(value) => response_data.insert("tx", value),
Err(e) => {
error!("Error reading tx: {}", e);
//response_data.insert("tx", "Error".to_string())
None
}
};
match statement.read::<String, _>("our_address") {
Ok(value) => response_data.insert("our_address", value),
Err(e) => {
error!("Error reading address: {}", e);
//response_data.insert("tx", "Error".to_string())
None
}
};
match statement.read::<String, _>("our_fees") {
Ok(value) => response_data.insert("our_fees", value),
Err(e) => {
error!("Error reading fees: {}", e);
//response_data.insert("tx", "Error".to_string())
None
}
};
// Read the request id (reqid)
match statement.read::<String, _>("reqid") {
Ok(value) => response_data.insert("time", value),
Err(e) => {
error!("Error reading reqid: {}", e);
//response_data.insert("time", "Error".to_string())
None
}
};
response = match serde_json::to_string(&response_data) {
Ok(json_data) => Response::new(full(json_data)),
Err(_) => response,
};
return Ok(response);
}
}
Ok(response)
}
async fn echo_push(
whole_body: &Bytes,
cfg: &MyConfig,
param: &str,
db: &Arc<Mutex<Connection>>,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
//let whole_body = req.collect().await?.to_bytes();
trace!("echo_push");
let strbody = match std::str::from_utf8(whole_body) {
Ok(s) => s,
Err(_) => {
return Ok(Response::new(full("Invalid UTF-8 body")));
}
};
let mut response = Response::new(full("Bad data received".to_owned()));
let mut response_not_enable = Response::new(full("Network not enabled".to_owned()));
*response.status_mut() = StatusCode::BAD_REQUEST;
*response_not_enable.status_mut() = StatusCode::BAD_REQUEST;
let netconfig = MyConfig::get_net_config(cfg, param);
if !netconfig.enabled {
trace!("network not enabled {}", &netconfig.name);
return Ok(response_not_enable);
}
let req_time = match Utc::now().timestamp_nanos_opt() {
Some(t) => t,
None => {
error!("Invalid timestamp");
return Ok(response);
}
}; // Returns i64
let db = match db.lock() {
Ok(g) => g,
Err(p) => {
error!("DB mutex poisoned in echo_push");
p.into_inner()
}
};
let lines = strbody.split("\n");
let sqltxshead = "INSERT INTO tbl_tx (txid, wtxid, ntxid, tx, locktime, reqid, network, our_address, our_fees)".to_string();
let mut sqltxs = "".to_string();
let sqlinpshead = "INSERT INTO tbl_inp (txid, in_txid, in_vout )".to_string();
let mut sqlinps = "".to_string();
let sqloutshead = "INSERT INTO tbl_out (txid, vout, script_pubkey, amount )".to_string();
let mut sqlouts = "".to_string();
let mut union_tx = true;
let mut union_inps = true;
let mut union_outs = true;
let mut already_present = false;
let mut ptx: Vec<(usize, Value)> = vec![];
let mut pinps: Vec<(usize, Value)> = vec![];
let mut pouts: Vec<(usize, Value)> = vec![];
let mut linenum = 1;
let mut lineinp = 1;
let mut lineout = 1;
for line in lines {
if line.is_empty() {
trace!("line len is: {}", line.len());
continue;
}
let linea = format!("{req_time}:{line}");
info!("New Tx: {}", linea);
let raw_tx = match Vec::<u8>::from_hex(line) {
Ok(raw_tx) => raw_tx,
Err(err) => {
error!("rawtx error: {}", err);
continue;
}
};
if !raw_tx.is_empty() {
trace!("len: {}", raw_tx.len());
let tx: Transaction = match consensus::deserialize(&raw_tx) {
Ok(tx) => tx,
Err(err) => {
error!("error: unable to parse tx: {}\n{}", line, err);
continue;
}
};
let txid = tx.compute_txid().to_string();
trace!("txid: {}", txid);
let mut statement = db.prepare("SELECT * FROM tbl_tx WHERE txid = ?").unwrap();
statement.bind((1, &txid[..])).unwrap();
if let Ok(State::Row) = statement.next() {
trace!("already present");
already_present = true;
continue;
}
let ntxid = tx.compute_ntxid();
let wtxid = tx.compute_wtxid();
let mut found = false;
let locktime = tx.lock_time;
let mut our_address: String = "".to_string();
let mut our_fees: u64 = 0;
for input in tx.input {
if !union_inps {
sqlinps = format!("{sqlinps} UNION ALL");
} else {
union_inps = false;
}
sqlinps = format!("{sqlinps} SELECT ?, ?, ?");
pinps.push((lineinp, Value::String(txid.to_string())));
pinps.push((
lineinp + 1,
Value::String(input.previous_output.txid.to_string()),
));
pinps.push((
lineinp + 2,
Value::String(input.previous_output.vout.to_string()),
));
lineinp += 3;
}
if netconfig.fixed_fee == 0 {
found = true;
}
for (idx, output) in tx.output.into_iter().enumerate() {
let script_pubkey = output.script_pubkey;
let address = match bitcoin::Address::from_script(
script_pubkey.as_script(),
netconfig.network,
) {
Ok(address) => address.to_string(),
Err(_) => String::new(),
};
let amount = output.value;
our_fees = netconfig.fixed_fee; //search wllexecutor output
if netconfig.xpub {
let sql = "select * from tbl_address where address=?";
let mut stmt = db.prepare(sql).expect("failed to fetch addresses");
stmt.bind((1, Value::String(address.to_string()))).unwrap();
if let Ok(State::Row) = stmt.next() {
our_address = address.to_string();
}
} else {
our_address = netconfig.address.to_string();
}
if address == our_address && amount.to_sat() >= netconfig.fixed_fee {
our_fees = amount.to_sat();
//our_address = netconfig.address.to_string();
found = true;
trace!("address and fees are correct {}: {}", our_address, our_fees);
}
if !union_outs {
sqlouts = format!("{sqlouts} UNION ALL");
} else {
union_outs = false;
}
sqlouts = format!("{sqlouts} SELECT ?, ?, ?, ?");
pouts.push((lineout, Value::String(txid.to_string())));
pouts.push((lineout + 1, Value::Integer(i64::try_from(idx).unwrap_or(-1))));
pouts.push((lineout + 2, Value::String(script_pubkey.to_string())));
pouts.push((
lineout + 3,
Value::Integer(i64::try_from(amount.to_sat()).unwrap_or(0)),
));
lineout += 4;
}
if !found {
error!("willexecutor output not found ");
return Ok(response);
} else {
if !union_tx {
sqltxs = format!("{sqltxs} UNION ALL");
} else {
union_tx = false;
}
sqltxs = format!("{sqltxs} SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?");
ptx.push((linenum, Value::String(txid)));
ptx.push((linenum + 1, Value::String(wtxid.to_string())));
ptx.push((linenum + 2, Value::String(ntxid.to_string())));
ptx.push((linenum + 3, Value::String(line.to_string())));
ptx.push((linenum + 4, Value::String(locktime.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 + 7, Value::String(our_address.to_string())));
ptx.push((linenum + 8, Value::String(our_fees.to_string())));
linenum += 9;
}
} else {
trace!("rawTx len is: {}", raw_tx.len());
debug!("{}", &sqltxs);
}
}
if sqltxs.is_empty() && already_present {
return Ok(Response::new(full("already present")));
}
let sqltxs = format!("{}{};", sqltxshead, sqltxs);
let sqlinps = format!("{}{};", sqlinpshead, sqlinps);
let sqlouts = format!("{}{};", sqloutshead, sqlouts);
if let Err(err) = execute_insert(&db, sqltxs, ptx, sqlinps, pinps, sqlouts, pouts) {
debug!("{}", err);
return Ok(response);
}
Ok(Response::new(full("thx")))
}
fn match_uri<'a>(path: &str, uri: &'a str) -> Option<&'a str> {
let re = Regex::new(path).unwrap();
if let Some(captures) = re.captures(uri) {
if let Some(param) = captures.name("param") {
return Some(param.as_str());
}
}
None
}
async fn echo(
req: Request<hyper::body::Incoming>,
cfg: &MyConfig,
ip: &String,
db: &Arc<Mutex<Connection>>,
) -> Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> {
let mut not_found = Response::new(empty());
*not_found.status_mut() = StatusCode::NOT_FOUND;
let mut ret: Result<Response<BoxBody<Bytes, hyper::Error>>, hyper::Error> = Ok(not_found);
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());
trace!("{}: {}", remote_addr, uri);
match *req.method() {
// Serve some instructions at /
Method::POST => {
let whole_body = req.collect().await?.to_bytes();
if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/pushtxs$", uri.as_str()) {
//let whole_body = collect_body(req,512_000).await?;
ret = echo_push(&whole_body, cfg, param, db).await;
}
if uri == "/searchtx" {
//let whole_body = collect_body(req,64).await?;
ret = echo_search(&whole_body, cfg, db).await;
}
ret
}
Method::GET => {
if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/stats$", uri.as_str()) {
ret = echo_stats(param, cfg, db).await;
}
if let Some(param) = match_uri(r"^?/?(?P<param>[^/]?+)?/info$", uri.as_str()) {
ret = echo_info(param, cfg, &remote_addr, db).await;
}
if uri == "/version" {
ret = echo_version().await;
}
if uri == "/.pub_key.pem" {
ret = echo_pub_key(cfg).await;
}
if uri == "/" {
ret = echo_home(cfg).await;
}
ret
}
// Return the 404 Not Found for other routes.
_ => ret,
}
}
fn empty() -> BoxBody<Bytes, hyper::Error> {
Empty::<Bytes>::new()
.map_err(|never| match never {})
.boxed()
}
fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
Full::new(chunk.into())
.map_err(|never| match never {})
.boxed()
}
fn parse_env(cfg: &Arc<Mutex<MyConfig>>) {
//for (key, value) in std::env::vars() {
// debug!("ENVIRONMENT {key}: {value}");
//}
let mut cfg_lock = match cfg.lock() {
Ok(g) => g,
Err(p) => {
error!("Config mutex poisoned in parse_env, recovering");
p.into_inner()
}
};
if let Ok(value) = env::var("BAL_SERVER_DB_FILE") {
debug!("BAL_SERVER_DB_FILE: {}", value);
cfg_lock.db_file = value;
}
if let Ok(value) = env::var("BAL_SERVER_BIND_ADDRESS") {
debug!("BAL_SERVER_BIND_ADDRESS: {}", value);
cfg_lock.bind_address = value;
}
if let Ok(value) = env::var("BAL_SERVER_BIND_PORT") {
debug!("BAL_SERVER_BIND_PORT: {}", value);
if let Ok(v) = value.parse::<u16>() {
cfg_lock.bind_port = v;
}
}
if let Ok(value) = env::var("BAL_SERVER_PUB_KEY_PATH") {
debug!("BAL_SERVER_PUB_KEY_PATH: {}", value);
cfg_lock.pub_key_path = value;
}
if let Ok(value) = env::var("BAL_SERVER_INFO") {
debug!("BAL_SERVER_INFO: {}", value);
cfg_lock.info = value;
}
cfg_lock = parse_env_netconfig(cfg_lock, "regtest");
cfg_lock = parse_env_netconfig(cfg_lock, "signet");
cfg_lock = parse_env_netconfig(cfg_lock, "testnet");
cfg_lock = parse_env_netconfig(cfg_lock, "testnet4");
drop(parse_env_netconfig(cfg_lock, "bitcoin"));
}
fn parse_env_netconfig<'a>(
mut cfg_lock: MutexGuard<'a, MyConfig>,
chain: &'a str,
) -> MutexGuard<'a, MyConfig> {
let cfg = match chain {
"regtest" => &mut cfg_lock.regtest,
"signet" => &mut cfg_lock.signet,
"testnet" => &mut cfg_lock.testnet,
"testnet4" => &mut cfg_lock.testnet4,
&_ => &mut cfg_lock.mainnet,
};
if let Ok(value) = env::var(format!("BAL_SERVER_{}_ADDRESS", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_ADDRESS: {}", chain.to_uppercase(), value);
cfg.address = value;
if cfg.address.len() > 5 {
if cfg.address[1..4] == *"pub" {
cfg.xpub = true;
trace!("is_xpub");
}
cfg.enabled = true;
}
}
if let Ok(value) = env::var(format!("BAL_SERVER_{}_FIXED_FEE", chain.to_uppercase())) {
debug!("BAL_SERVER_{}_FIXED_FEE: {}", chain.to_uppercase(), value);
if let Ok(v) = value.parse::<u64>() {
cfg.fixed_fee = v;
}
}
cfg_lock
}
fn init_network(db: &Connection, cfg: &MyConfig) {
for network in NETWORKS {
let netconfig = MyConfig::get_net_config(cfg, network);
insert_xpub(db, &netconfig.name, &netconfig.address);
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
env_logger::init();
let cfg: Arc<Mutex<MyConfig>> = Arc::<Mutex<MyConfig>>::default();
parse_env(&cfg);
let cfg_lock = match cfg.lock() {
Ok(g) => g,
Err(p) => {
error!("Config mutex poisoned at startup, recovering");
p.into_inner()
}
};
let db = Arc::new(Mutex::new(sqlite::open(&cfg_lock.db_file).unwrap()));
let db_guard = db.lock().unwrap();
create_database(&*db_guard);
init_network(&*db_guard, &cfg_lock);
drop(db_guard);
let addr = cfg_lock.bind_address.to_string();
let addr: IpAddr = addr.parse()?;
let listener = TcpListener::bind((addr, cfg_lock.bind_port)).await?;
info!("Listening on http://{}:{}", addr, cfg_lock.bind_port);
loop {
let (stream, _) = listener.accept().await?;
let ip = stream
.peer_addr()?
.to_string()
.split(':')
.next()
.unwrap()
.to_string();
let io = TokioIo::new(stream);
tokio::task::spawn({
let cfg = cfg_lock.clone();
let db = db.clone();
async move {
if let Err(err) = http1::Builder::new()
.serve_connection(
io,
service_fn(|req: Request<hyper::body::Incoming>| async {
echo(req, &cfg, &ip, &db).await
}),
)
.await
{
error!("Error serving connection: {:?}", err);
}
}
});
}
}

168
src/db.rs
View File

@@ -1,5 +1,121 @@
use log::{error, info, trace};
use sqlite::{Connection, Error, State, Value};
use std::collections::HashSet;
use std::path::Path;
/// Check which txids are already present in the database in a single batch query.
/// Returns a HashSet of txids that already exist (duplicates).
/// This is O(1) per query regardless of the number of txids, replacing the N+1 pattern.
pub fn check_duplicate_txids(db: &Connection, txids: &[String]) -> Result<HashSet<String>, Error> {
if txids.is_empty() {
return Ok(HashSet::new());
}
// Build a single query with all txids using IN clause placeholders
// SQLite supports up to 1000 parameters per statement, so we chunk for safety
let mut duplicates = HashSet::new();
let chunk_size = 500; // Safe chunk size for SQLite parameters
for chunk in txids.chunks(chunk_size) {
let placeholders = chunk.iter().map(|_| "?").collect::<Vec<_>>().join(",");
let sql = format!("SELECT txid FROM tbl_tx WHERE txid IN ({})", placeholders);
let mut stmt = db.prepare(sql)?;
for (i, txid) in chunk.iter().enumerate() {
stmt.bind((i + 1, Value::String(txid.clone())))?;
}
while let Ok(State::Row) = stmt.next() {
if let Ok(txid) = stmt.read::<String, _>("txid") {
duplicates.insert(txid);
}
}
}
Ok(duplicates)
}
/// Validates and opens the SQLite database, enforcing security best practices:
/// - Path must not contain `..` (directory traversal).
/// - Absolute paths must not target known system directories.
/// - If the file exists, it must be a regular file (not a symlink or device).
/// - WAL journal mode is enabled for safe concurrent access.
/// - Synchronous is set to NORMAL for performance with safety.
///
/// Returns `Err` on validation failure or open error to prevent panics.
pub fn open_db(path: &str) -> Result<Connection, String> {
let p = Path::new(path);
// Prevent directory traversal
for component in p.components() {
if component == std::path::Component::ParentDir {
return Err("Database path may not contain '..'".to_string());
}
}
// If absolute, block known sensitive system directories
if p.is_absolute() {
let path_str = p.to_str().unwrap_or("");
let forbidden = [
"/etc", "/proc", "/sys", "/dev", "/usr", "/bin", "/sbin", "/lib", "/opt",
];
for prefix in &forbidden {
if path_str.starts_with(prefix) {
return Err(
format!(
"Absolute database path under {} is forbidden",
prefix
)
);
}
}
}
// If file exists, must be a regular file (not a symlink, device, etc.)
if p.exists() {
if p.is_symlink() {
return Err(
"Database path must not be a symlink".to_string()
);
}
let metadata = std::fs::metadata(p)
.map_err(|e| format!("Cannot access database file metadata: {}", e))?;
if !metadata.is_file() {
return Err(
"Database path must point to a regular file, not a directory or device".to_string()
);
}
}
let conn = sqlite::open(path)
.map_err(|e| format!("Failed to open SQLite database: {}", e))?;
conn.execute("PRAGMA journal_mode = WAL;")
.map_err(|e| format!("Failed to enable WAL mode: {}", e))?;
conn.execute("PRAGMA synchronous = NORMAL;")
.map_err(|e| format!("Failed to set synchronous NORMAL: {}", e))?;
Ok(conn)
}
/// Loads all known addresses for a given xpub into a HashSet for fast
/// in-memory lookup during transaction validation (replaces N+1 query).
pub fn get_all_addresses_by_xpub(db: &Connection, xpub: &str) -> Result<HashSet<String>, Error> {
let mut stmt = db.prepare(
"SELECT a.address FROM tbl_address a JOIN tbl_xpub x ON a.xpub = x.id WHERE x.xpub = ?"
)?;
stmt.bind((1, Value::String(xpub.to_string())))?;
let mut addresses = HashSet::new();
while let Ok(State::Row) = stmt.next() {
match stmt.read::<String, _>("address") {
Ok(addr) => { addresses.insert(addr); }
Err(e) => {
error!("Failed to read address column: {}", e);
}
}
}
Ok(addresses)
}
pub fn create_database(db: &Connection) {
info!("database sanity check");
@@ -17,6 +133,9 @@ pub fn create_database(db: &Connection) {
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_stats (report_date TEXT, chain TEXT, totals INTEGER, waiting INTEGER, sent INTEGER, failed INTEGER, waiting_profit INTEGER, sent_profit INTEGER, missed_profit INTEGER, unique_inputs INTEGER);");
let _ = db.execute("CREATE INDEX IF NOT EXISTS idx_stats_chain ON tbl_stats(chain);");
let _ = db.execute("UPDATE tbl_tx set network='bitcoin' where network='mainnet');");
}
/*
@@ -109,28 +228,24 @@ pub fn get_next_address_index(db: &Connection, network: &String, xpub: &String)
return (0, 0);
}
match stmt.next() {
Ok(State::Row) => {
match stmt.read::<i64, _>("path_idx") {
Ok(next) => match stmt.read::<i64, _>("id") {
Ok(id) => (id, next),
Err(e) => {
error!("Failed to read id column: {}", e);
(0, 0)
}
},
Ok(State::Row) => match stmt.read::<i64, _>("path_idx") {
Ok(next) => match stmt.read::<i64, _>("id") {
Ok(id) => (id, next),
Err(e) => {
error!("Failed to read path_idx column: {}", e);
error!("Failed to read id column: {}", e);
(0, 0)
}
},
Err(e) => {
error!("Failed to read path_idx column: {}", e);
(0, 0)
}
}
},
Err(e) => {
error!("Failed to execute xpub index update: {}", e);
(0, 0)
}
Ok(State::Done) => {
(0, 0)
}
Ok(State::Done) => (0, 0),
}
}
pub fn save_new_address(
@@ -140,8 +255,10 @@ pub fn save_new_address(
path: &String,
remote_addr: &String,
) {
let mut stmt = match db.prepare("INSERT INTO tbl_address(address,path,xpub,remote_address) VALUES(?,?,?,?);
") {
let mut stmt = match db.prepare(
"INSERT INTO tbl_address(address,path,xpub,remote_address) VALUES(?,?,?,?);
",
) {
Ok(s) => s,
Err(e) => {
error!("Failed to prepare address insert statement: {}", e);
@@ -241,21 +358,22 @@ pub fn execute_insert(
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 = ?;")
.map_err(|e| { error!("Failed to prepare statement: {}", e); e })?;
.map_err(|e| {
error!("Failed to prepare statement: {}", e);
e
})?;
if let Err(e) = stmt.bind((1, Value::String(network.to_string()))) {
error!("Failed to bind network parameter: {}", e);
return Err(e);
}
match stmt.next() {
Ok(State::Row) => {
match stmt.read::<i64, _>("total_number") {
Ok(val) => Ok(val),
Err(e) => {
error!("Failed to read total_number column: {}", e);
Err(e)
}
Ok(State::Row) => match stmt.read::<i64, _>("total_number") {
Ok(val) => Ok(val),
Err(e) => {
error!("Failed to read total_number column: {}", e);
Err(e)
}
}
},
Ok(sqlite::State::Done) => Ok(0),
Err(err) => {
error!("Failed to execute query: {}", err);

3
src/lib.rs Normal file
View File

@@ -0,0 +1,3 @@
pub mod db;
pub mod validation;
pub mod xpub;

168
src/validation.rs Normal file
View File

@@ -0,0 +1,168 @@
use url::Url;
/// Validates a WELIST server URL to mitigate SSRF risks.
///
/// Checks:
/// 1. URL must be well-formed and parsable.
/// 2. Scheme must be `https://` (plain HTTP is rejected).
/// 3. Host must be present.
/// 4. Host must not be `localhost` or loopback strings.
/// 5. Host must not resolve to a loopback, private, link-local, unspecified, or multicast IP address.
/// 6. IPv6 Unique Local (fc00::/7) is also rejected.
///
/// Returns `true` if the URL is safe to use, `false` otherwise.
///
/// Examples:
/// - `is_valid_welist_url("https://welist.bitcoin-after.life")` -> `true`
/// - `is_valid_welist_url("https://welist.bitcoin-after.life:443")` -> `true`
/// - `is_valid_welist_url("https://example.com/ping")` -> `true`
/// - `is_valid_welist_url("http://welist.bitcoin-after.life")` -> `false` (not HTTPS)
/// - `is_valid_welist_url("https://localhost")` -> `false` (localhost loopback)
/// - `is_valid_welist_url("https://127.0.0.1")` -> `false` (IPv4 loopback)
/// - `is_valid_welist_url("https://169.254.169.254")` -> `false` (AWS metadata link-local)
/// - `is_valid_welist_url("https://192.168.1.1")` -> `false` (IPv4 private)
/// - `is_valid_welist_url("https://10.0.0.1")` -> `false` (IPv4 private RFC1918)
pub fn is_valid_welist_url(url_str: &str) -> bool {
let url = match Url::parse(url_str) {
Ok(u) => u,
Err(_e) => return false,
};
if url.scheme() != "https" {
return false;
}
let host = match url.host_str() {
Some(h) => h.trim_start_matches('[').trim_end_matches(']'),
None => return false,
};
if host.eq_ignore_ascii_case("localhost")
|| host.eq_ignore_ascii_case("127.0.0.1")
|| host.eq_ignore_ascii_case("::1")
{
return false;
}
if let Ok(ip) = host.parse::<std::net::IpAddr>() {
match ip {
std::net::IpAddr::V4(v4) => {
if v4.is_loopback()
|| v4.is_private()
|| v4.is_link_local()
|| v4.is_unspecified()
|| v4.is_multicast()
{
return false;
}
}
std::net::IpAddr::V6(v6) => {
if v6.is_loopback()
|| v6.is_unicast_link_local()
|| v6.is_unspecified()
|| v6.is_multicast()
|| v6.is_unique_local()
{
return false;
}
}
}
}
true
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_valid_domains() {
assert!(is_valid_welist_url("https://welist.bitcoin-after.life"));
assert!(is_valid_welist_url("https://welist.bitcoin-after.life:443"));
assert!(is_valid_welist_url("https://example.com/ping"));
assert!(is_valid_welist_url("https://a.b.c.d.example.com"));
assert!(is_valid_welist_url("https://welist.onion.tor"));
}
#[test]
fn test_invalid_scheme() {
assert!(!is_valid_welist_url("http://welist.bitcoin-after.life"));
assert!(!is_valid_welist_url("ftp://welist.bitcoin-after.life"));
assert!(!is_valid_welist_url("https://")); // no host
}
#[test]
fn test_localhost_and_loopback() {
assert!(!is_valid_welist_url("https://localhost"));
assert!(!is_valid_welist_url("https://localhost:8080"));
assert!(
!is_valid_welist_url("https://LOCALHOST"),
"Uppercase localhost should be blocked"
);
assert!(!is_valid_welist_url("https://127.0.0.1"));
assert!(!is_valid_welist_url("https://127.0.0.1:8080"));
assert!(
!is_valid_welist_url("https://127.0.0.2"),
"Other loopback in 127/8 should be blocked"
);
assert!(
!is_valid_welist_url("https://[::1]"),
"IPv6 loopback literal should be blocked"
);
assert!(
!is_valid_welist_url("https://::1"),
"Raw IPv6 loopback without brackets should be invalid (parse fails)"
);
}
#[test]
fn test_private_ips() {
assert!(!is_valid_welist_url("https://192.168.1.1"));
assert!(!is_valid_welist_url("https://10.0.0.1"));
assert!(!is_valid_welist_url("https://172.16.0.1"));
assert!(!is_valid_welist_url("https://172.31.255.255"));
assert!(
!is_valid_welist_url("https://169.254.169.254"),
"AWS metadata link-local IP should be blocked"
);
}
#[test]
fn test_unspecified_and_multicast() {
assert!(!is_valid_welist_url("https://0.0.0.0"));
assert!(!is_valid_welist_url("https://224.0.0.1"));
}
#[test]
fn test_ipv6_link_local() {
assert!(
!is_valid_welist_url("https://[fe80::1]"),
"IPv6 link local should be blocked"
);
}
#[test]
fn test_ipv6_unique_local() {
assert!(
!is_valid_welist_url("https://[fc00::1]"),
"IPv6 unique local (fc00::/7) should be blocked"
);
assert!(
!is_valid_welist_url("https://[fd00::1]"),
"IPv6 unique local (fd00::7) should be blocked"
);
}
#[test]
fn test_malformed_urls() {
assert!(!is_valid_welist_url("not a url"));
assert!(!is_valid_welist_url("welist.bitcoin-after.life")); // missing scheme
}
#[test]
fn test_valid_public_ip() {
assert!(is_valid_welist_url("https://1.2.3.4"));
assert!(is_valid_welist_url("https://8.8.8.8"));
}
}

16
src/xpub.rs
View File

@@ -125,11 +125,7 @@ pub fn get_bitcoincore_descriptor(xpub: &String) -> String {
Ok(c) => c,
Err(_) => return String::new(), // Invalid xpub, return empty descriptor
};
let descriptor = format!(
"wpkh([{}/84h/0h/0h]{}/0/*)",
fingerprint,
xpub_converted
);
let descriptor = format!("wpkh([{}/84h/0h/0h]{}/0/*)", fingerprint, xpub_converted);
let descriptor = match calc_checksum(&descriptor) {
Ok(checksum) => {
let clean_descriptor = descriptor.split('#').next().unwrap_or(&descriptor);
@@ -144,16 +140,20 @@ pub fn get_bitcoincore_descriptor(xpub: &String) -> String {
//format!("{}#{}",descriptor,checksum)
}
fn convert_xpub(xpub: &String) -> Result<String, String> {
if xpub.len() >= 4 && (&xpub[0..4] == "xpub" || &xpub[0..4] == "ypub" || &xpub[0..4] == "zpub") {
if xpub.len() >= 4 && (&xpub[0..4] == "xpub" || &xpub[0..4] == "ypub" || &xpub[0..4] == "zpub")
{
convert_to(xpub, BS58Prefix::Xpub)
} else if xpub.len() >= 4 && (&xpub[0..4] == "tpub" || &xpub[0..4] == "vpub" || &xpub[0..4] == "upub") {
} else if xpub.len() >= 4
&& (&xpub[0..4] == "tpub" || &xpub[0..4] == "vpub" || &xpub[0..4] == "upub")
{
convert_to(xpub, BS58Prefix::Tpub)
} else {
Err("Invalid xpub prefix: expected xpub, ypub, zpub, tpub, vpub, or upub".to_string())
}
}
pub fn calculate_fingerprint(tpub: &str) -> Result<String, String> {
let xpub = Xpub::from_str(&convert_to(tpub, BS58Prefix::Xpub)?).map_err(|e| format!("Invalid xpub: {}", e))?;
let xpub = Xpub::from_str(&convert_to(tpub, BS58Prefix::Xpub)?)
.map_err(|e| format!("Invalid xpub: {}", e))?;
let fp = xpub.fingerprint();
let _pp = xpub.parent_fingerprint;
Ok(format!("{}", fp))