Upgrade Botimus to handle loan calc and validation

bobtimus/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 [dependencies]
 anyhow = "1"
 async-trait = "0.1"
-baru = { git = "https://github.com/da-kami/baru", branch = "lender-decides-timelock" }
+baru = "0.3"
 bitcoin_hashes = "0.9.0"
 diesel = { version = "1.4", features = ["sqlite"] }
 diesel_migrations = "1.4"
@@ -31,6 +31,7 @@ serde_json = "1"
 sha2 = "0.9"
 structopt = "0.3"
 tempfile = "3.2"
+thiserror = "1"
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 tokio-tungstenite = { version = "0.13", features = ["tls"] }
 tracing = "0.1"

bobtimus/proptest-regressions/lib.txt

@@ -5,3 +5,4 @@
 # It is recommended to check this file in to source control so that
 # everyone who runs the test benefits from these saved cases.
 cc 9bb7f1b54a4968641948d278e51a05ed2930034b95de73641862e33bfcdcea4d # shrinks to term_in_days = 30868
+cc 1ea9687935221688e83172c1a589fbb8beb2dbfeb527c320dd9810a402281a8a # shrinks to principal_amount = 15775565394041882682, interest_percentage = 0.16932377

bobtimus/src/amounts.rs

@@ -5,7 +5,7 @@ use rust_decimal::{
  Decimal, RoundingStrategy,
 };
 use serde::{Deserialize, Serialize};
-use std::{convert::TryFrom, fmt::Debug};
+use std::{convert::TryFrom, fmt, fmt::Debug};
 
 /// Prices at which 1 L-BTC will be traded, in L-USDt.
 ///
@@ -62,7 +62,7 @@ impl Rate {
  }
 }
 
-#[derive(Clone, Copy, PartialEq, Serialize, Default)]
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Serialize, Deserialize, Default)]
 pub struct LiquidUsdt(#[serde(with = "::elements::bitcoin::util::amount::serde::as_sat")] Amount);
 
 impl LiquidUsdt {
@@ -125,8 +125,17 @@ impl TryFrom<f64> for LiquidUsdt {
  }
 }
 
+impl fmt::Display for LiquidUsdt {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.0.fmt_value_in(f, Denomination::Bitcoin)?;
+ write!(f, " L-USDT")
+ }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-pub struct LiquidBtc(#[serde(with = "::elements::bitcoin::util::amount::serde::as_sat")] Amount);
+pub struct LiquidBtc(
+ #[serde(with = "::elements::bitcoin::util::amount::serde::as_sat")] pub Amount,
+);
 
 impl From<Amount> for LiquidBtc {
  fn from(amount: Amount) -> Self {

bobtimus/src/lib.rs

@@ -43,9 +43,12 @@ pub mod loan;
 pub mod problem;
 pub mod schema;
 
-use crate::loan::{Interest, LoanOffer, LoanRequest};
+use crate::loan::{
+ loan_calculation_and_validation, Collateralization, LoanOffer, LoanRequest, Term, ValidatedLoan,
+};
 pub use amounts::*;
 use elements::bitcoin::PublicKey;
+use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 use std::{
  convert::TryFrom,
@@ -270,32 +273,70 @@ where
  /// We return the range of possible loan terms to the borrower.
  /// The borrower can then request a loan using parameters that are within our terms.
  pub async fn handle_loan_offer_request(&mut self) -> Result<LoanOffer> {
- Ok(LoanOffer {
+ Ok(self.current_loan_offer())
+ }
+
+ fn current_loan_offer(&mut self) -> LoanOffer {
+ LoanOffer {
  rate: self.rate_service.latest_rate(),
  // TODO: Dynamic fee estimation
  fee_sats_per_vbyte: Amount::from_sat(1),
- // TODO: Send sats over the wire and refactor waves reducer to use amount classes
  min_principal: LiquidUsdt::from_str_in_dollar("100")
  .expect("static value to be convertible"),
  max_principal: LiquidUsdt::from_str_in_dollar("10000")
  .expect("static value to be convertible"),
+ // TODO: Maximum LTV to be decided by a model
  max_ltv: dec!(0.8),
- // TODO: Dynamic interest based on current market values
- interest: vec![Interest {
- term: 30,
- interest_rate: dec!(0.15),
- collateralization: dec!(1.5),
- }],
- })
+ // TODO: Interest to be decided by a model
+ base_interest_rate: dec!(0.05),
+ // TODO: Potentially fine-tune the model with these values
+ terms: vec![
+ Term {
+ days: 30,
+ interest_mod: Decimal::ZERO,
+ },
+ Term {
+ days: 60,
+ interest_mod: Decimal::ZERO,
+ },
+ Term {
+ days: 120,
+ interest_mod: Decimal::ZERO,
+ },
+ ],
+ collateralizations: vec![
+ Collateralization {
+ collateralization: dec!(1.5),
+ interest_mod: Decimal::ZERO,
+ },
+ Collateralization {
+ collateralization: dec!(2.0),
+ interest_mod: Decimal::ZERO,
+ },
+ ],
+ }
  }
 
  /// Handle the borrower's loan request in which she puts up L-BTC as
  /// collateral and we lend L-USDt to her which she will have to
  /// repay in the future.
- pub async fn handle_loan_request(&mut self, payload: LoanRequest) -> Result<LoanResponse> {
- // TODO: Ensure that the loan requested is within what we "currently" accept.
- // Currently there is no ID for incoming loan requests, that would associate them with an offer,
- // so we just have to ensure that the loan is still "acceptable" in the current state of Bobtimus.
+ pub async fn handle_loan_request(&mut self, loan_request: LoanRequest) -> Result<LoanResponse> {
+ let loan_offer = self.current_loan_offer();
+ // TODO: Make configurable
+ let price_fluctuation_interval = (dec!(0.99), dec!(1.01));
+
+ // The bid price is used so the lender is covered under the assumption of selling the asset
+ let current_price = self.rate_service.latest_rate().bid;
+
+ let ValidatedLoan {
+ repayment_amount,
+ liquidation_price,
+ } = loan_calculation_and_validation(
+ &loan_request,
+ &loan_offer,
+ price_fluctuation_interval,
+ current_price,
+ )?;
 
  let oracle_secret_key = elements::secp256k1_zkp::key::ONE_KEY;
  let oralce_priv_key = elements::bitcoin::PrivateKey::new(
@@ -304,7 +345,7 @@ where
  );
  let oracle_pk = PublicKey::from_private_key(&self.secp, &oralce_priv_key);
 
- let timelock = days_to_unix_timestamp_timelock(payload.term, SystemTime::now())?;
+ let timelock = days_to_unix_timestamp_timelock(loan_request.term, SystemTime::now())?;
 
  let lender_address = self
  .elementsd
@@ -327,22 +368,31 @@ where
  )
  .unwrap();
 
+ let elementsd_client = self.elementsd.clone();
+ let principal_inputs = Self::find_inputs(
+ &elementsd_client,
+ self.usdt_asset_id,
+ loan_request.principal_amount.into(),
+ )
+ .await?;
+
  let lender1 = lender0
- .interpret(
+ .build_loan_transaction(
  &mut self.rng,
  &SECP256K1,
- {
- let elementsd_client = self.elementsd.clone();
- |amount, asset| async move {
- Self::find_inputs(&elementsd_client, asset, amount).await
- }
- },
- payload.into(),
- self.rate_service.latest_rate().bid.as_satodollar(),
+ loan_offer.fee_sats_per_vbyte,
+ (
+ loan_request.collateral_amount.into(),
+ loan_request.collateral_inputs,
+ ),
+ (loan_request.principal_amount.into(), principal_inputs),
+ repayment_amount.into(),
+ liquidation_price.as_satodollar(),
+ (loan_request.borrower_pk, loan_request.borrower_address),
  timelock,
  )
  .await
- .unwrap();
+ .context("Failed to build loan transaction")?;
 
  let loan_response = lender1.loan_response();