mte/src/config.ml

open Parse_config

let config_data =
  let path = Fpath.to_string (Fpath.v "default.config") in
  match Assets_crunch.read path with
  | None -> Fmt.failwith "static file not found: `%s`" path
  | Some data ->
      let v = Parse_data.parse data in
      (*Fmt.epr "config file:@\n%a@." Pp_debug.pp_config v;*)
      v

module Exchange = struct
  let get_opt field = get_opt config_data ~section:"exchange" ~field
  let get field = get config_data ~section:"exchange" ~field

  (* - *)
  let currency = (* todo: constraint on currency string *) get "currency"
  let currency_round_unit = get "currency_round_unit" |> amount
  let db = get "db" |> const_value "postgres"
  let attribute_encryption_key = get "attribute_encryption_key"
  let port = get "port" |> int
  let bind_to = get "bind_to"
  let master_public_key = get "master_public_key" |> ed25519
  let stefan_abs = get "stefan_abs" |> amount
  let stefan_log = get "stefan_log" |> amount
  let stefan_lin = get_opt "stefan_lin" |> Option.map float

  let aggregator_idle_sleep_interval =
    get "aggregator_idle_sleep_interval" |> duration

  let closer_idle_sleep_interval = get "closer_idle_sleep_interval" |> duration

  let transfer_idle_sleep_interval =
    get "transfer_idle_sleep_interval" |> duration

  let wirewatch_idle_sleep_interval =
    get "wirewatch_idle_sleep_interval" |> duration

  let signkey_legal_duration = get "signkey_legal_duration" |> duration
  let max_keys_caching = get "max_keys_caching" |> duration
  let enable_kyc = get "enable_kyc" |> yes_no
  let terms_etag = get "terms_etag"
  let privacy_etag = get "privacy_etag"

  (* optional:
       tiny_amount
       shopping_url
       open_banking_gateway_url
       aml_spa_dialect
       bank_compliance_language
       toplevel_redirect_url *)
  (* not implemented or not relevant to MTE:
       let max_requests = get "max_requests" |> int
       base_url
       aggregator_shard_size
       serve
       unixpath
       unixpath_mode
       terms_dir
       privacy_dir *)
end

module Exchangedb = struct
  let get field = get config_data ~section:"exchangedb" ~field

  (* - *)
  let idle_reserve_expiration_time =
    get "idle_reserve_expiration_time" |> duration

  let legal_reserve_expiration_time =
    get "legal_reserve_expiration_time" |> duration

  let aggregator_shift = get "aggregator_shift" |> duration
  let max_aml_program_runtime = get "max_aml_program_runtime" |> duration
  let default_purse_limit = get "default_purse_limit" |> int
end

module Exchangedb_postgres = struct
  let config =
    get config_data ~section:"exchangedb-postgres" ~field:"config" |> uri
end

module Currency = struct
  type t = {
    enabled: [ `YES | `NO ];
    code: string;
    name: string;
    fractional_input_digits: int;
    fractional_normal_digits: int;
    fractional_trailing_zero_digits: int;
    alt_unit_names: (int * string) list;
  }

  let currency_sections =
    List.filter
      (fun v -> String.starts_with ~prefix:"currency-" v.header)
      config_data

  let parse_currency section =
    let get field = get config_data ~section:section.header ~field in
    {
      enabled= get "enabled" |> yes_no;
      code= get "code";
      name= get "name";
      fractional_input_digits= get "fractional_input_digits" |> int;
      fractional_normal_digits= get "fractional_normal_digits" |> int;
      fractional_trailing_zero_digits=
        get "fractional_trailing_zero_digits" |> int;
      alt_unit_names= get "alt_unit_names" |> Parse_alt_unit_names.parse;
    }

  let all_currencies = List.map parse_currency currency_sections

  (* I think the exchange only handle one currency *)
  let v =
    match
      List.find_opt (fun v -> v.code = Exchange.currency) all_currencies
    with
    | None ->
        fail_with
          (Fmt.str
             "section `[currency-%s]` not found, currency `%s` is not defined"
             Exchange.currency Exchange.currency)
    | Some v -> (
        match v.enabled = `YES with
        | false ->
            fail_with (Fmt.str "currency `%s` is not enabled" Exchange.currency)
        | true -> v)
end

module Coin = struct
  type t = {
    section_name: string;
    value: Amount.t;
    duration_withdraw: Ptime.Span.t;
    duration_spend: Ptime.Span.t;
    duration_legal: Ptime.Span.t;
    fee_withdraw: Amount.t;
    fee_deposit: Amount.t;
    fee_refresh: Amount.t;
    fee_refund: Amount.t;
    cipher: [ (* `CS |*) `RSA ];
    rsa_keysize: int; (* : int option (only if `RSA) *)
    age_restricted: [ (*`YES|*) `NO ];
  }

  let coin_sections =
    List.filter
      (fun v ->
        (* note: here its a '_' not '-' *)
        String.starts_with ~prefix:"coin_" v.header)
      config_data

  let parse_coin section =
    let get field = get config_data ~section:section.header ~field in
    let section_name =
      String.sub section.header 5 (String.length section.header - 5)
    in
    {
      section_name;
      value= get "value" |> amount;
      duration_withdraw= get "duration_withdraw" |> duration;
      duration_spend= get "duration_spend" |> duration;
      duration_legal= get "duration_legal" |> duration;
      fee_withdraw= get "fee_withdraw" |> amount;
      fee_deposit= get "fee_deposit" |> amount;
      fee_refresh= get "fee_refresh" |> amount;
      fee_refund= get "fee_refund" |> amount;
      cipher= (get "cipher" |> const_value "RSA" |> fun _s -> `RSA);
      rsa_keysize= get "rsa_keysize" |> int;
      age_restricted=
        ( get "age_restricted" |> yes_no |> function
          | `NO -> `NO
          | `YES -> fail_with "`age_restricted = YES` is not supported" );
    }

  let all_coins = List.map parse_coin coin_sections

  let get_coin name =
    match List.find_opt (fun v -> v.section_name = name) all_coins with
    | None ->
        fail_with
          (Fmt.str "section `[coin_%s]` not found, coin `%s` is not defined"
             name name)
    | Some v -> v

  let kudo_1 = get_coin "kudo_1"
  let kudo_2 = get_coin "kudo_2"
end

module Exchange_secmod_rsa = struct
  let get field =
    let section = "taler-exchange-secmod-" ^ "rsa" in
    get config_data ~section ~field

  let lookahead_sign = get "lookahead_sign" |> duration
  let overlap_duration = get "overlap_duration" |> duration
  (* not relevant: sm_priv_key key_dir unixpath *)
end

module Exchange_secmod_eddsa = struct
  let get field =
    let section = "taler-exchange-secmod-" ^ "eddsa" in
    get config_data ~section ~field

  let lookahead_sign = get "lookahead_sign" |> duration
  let overlap_duration = get "overlap_duration" |> duration
end

(* -- *)
include Exchange