depolymerization

config.rs (5101B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::net::SocketAddr;
 
 use bitcoin::Amount;
 use sqlx::postgres::PgConnectOptions;
 use taler_api::{
     Serve,
     config::{ApiCfg, DbCfg},
 };
 use taler_common::{
     config::{Config, ValueErr},
     map_config,
     types::{amount::Currency, payto::PaytoURI},
 };
 
 use crate::{
     payto::{BtcWallet, FullBtcPayto},
     taler_utils::taler_to_btc,
 };
 
 pub fn parse_db_cfg(cfg: &Config) -> Result<DbCfg, ValueErr> {
     DbCfg::parse(cfg.section("depolymerizer-bitcoindb-postgres"))
 }
 
 pub fn parse_account_payto(cfg: &Config) -> Result<FullBtcPayto, ValueErr> {
     let sect = cfg.section("depolymerizer-bitcoin");
     let wallet: BtcWallet = sect.parse("bitcoin wallet address", "WALLET").require()?;
     let name = sect.str("NAME").require()?;
 
     Ok(FullBtcPayto::new(wallet, name))
 }
 
 #[derive(Debug, Clone)]
 pub enum RpcAuth {
     Cookie(String),
     Basic(String),
 }
 
 pub struct ServeCfg {
     pub payto: PaytoURI,
     pub serve: Serve,
     pub wire_gateway: Option<ApiCfg>,
     pub currency: Currency,
     pub lifetime: Option<u32>,
 }
 
 impl ServeCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let payto = parse_account_payto(cfg)?;
 
         let sect = cfg.section("depolymerizer-bitcoin-httpd");
 
         let lifetime = sect.number("LIFETIME").opt()?.filter(|it| *it != 0);
 
         let serve = Serve::parse(sect)?;
 
         let wire_gateway =
             ApiCfg::parse(cfg.section("depolymerizer-bitcoin-httpd-wire-gateway-api"))?;
 
         let sect = cfg.section("depolymerizer-bitcoin");
         Ok(Self {
             currency: sect.parse("currency", "CURRENCY").require()?,
             lifetime,
             payto: payto.as_payto(),
             serve,
             wire_gateway,
         })
     }
 }
 
 #[derive(Debug, Clone)]
 
 pub struct WorkerCfg {
     pub confirmation: u32,
     pub max_confirmation: u32,
     pub bounce_fee: Amount,
     pub lifetime: Option<u32>,
     pub bump_delay: Option<u32>,
     pub db_config: PgConnectOptions,
     pub currency: Currency,
     pub rpc_cfg: RpcCfg,
     pub wallet_cfg: WalletCfg,
 }
 
 impl WorkerCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let currency: Currency = cfg
             .section("depolymerizer-bitcoin")
             .parse("currency", "CURRENCY")
             .require()?;
 
         let sect = cfg.section("depolymerizer-bitcoin-worker");
         let confirmation = sect.number("CONFIRMATION").require()?;
 
         Ok(Self {
             confirmation,
             max_confirmation: confirmation * 2,
             bounce_fee: sect
                 .amount("BOUNCE_FEE", currency.as_ref())
                 .opt()?
                 .map(|it| taler_to_btc(&it))
                 .unwrap_or_default(),
             lifetime: sect.number("LIFETIME").opt()?.filter(|it| *it != 0),
             bump_delay: sect.number("BUMP_DELAY").opt()?.filter(|it| *it != 0),
             db_config: cfg
                 .section("depolymerizer-bitcoindb-postgres")
                 .parse("Postgres", "CONFIG")
                 .require()
                 .unwrap(),
             currency,
             rpc_cfg: RpcCfg::parse(cfg)?,
             wallet_cfg: WalletCfg::parse(cfg)?,
         })
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct WalletCfg {
     pub name: String,
     pub password: Option<String>,
 }
 
 impl WalletCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let sect = cfg.section("depolymerizer-bitcoin-worker");
         let password = sect.str("PASSWORD").opt()?;
         let name = sect.str("WALLET_NAME").require()?;
 
         Ok(Self { name, password })
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct RpcCfg {
     pub addr: SocketAddr,
     pub auth: RpcAuth,
 }
 
 impl RpcCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let sect = cfg.section("depolymerizer-bitcoin-worker");
 
         let addr = sect.parse("RPC server address", "RPC_BIND").require()?;
 
         let auth = map_config!(sect, "auth_method", "RPC_AUTH_METHOD",
             "basic" => {
                 let username = sect.str("RPC_USERNAME").require()?;
                 let password = sect.str("RPC_PASSWORD").require()?;
                 Ok(RpcAuth::Basic(format!("{username}:{password}")))
             },
             "cookie" => {
                 Ok(RpcAuth::Cookie(sect.path("RPC_COOKIE_FILE").require()?))
             }
         )
         .require()?;
 
         Ok(Self { addr, auth })
     }
 }