Expose error code for pocket offers

dleutenegger · dleutenegger · commit 019c6f4614bd · 2023-10-13T17:54:23.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -11,10 +11,10 @@ name = "uniffi_lipalightninglib"
 nigiri = []
 
 [dependencies]
-chameleon = { git = "https://github.com/getlipa/wild", tag = "v1.12.0" }
-crow = { git = "https://github.com/getlipa/wild", tag = "v1.12.0" }
-honey-badger = { git = "https://github.com/getlipa/wild", tag = "v1.12.0" }
-graphql = { git = "https://github.com/getlipa/wild", tag = "v1.12.0" }
+chameleon = { git = "https://github.com/getlipa/wild/", tag = "v1.13.0" }
+crow = { git = "https://github.com/getlipa/wild/", tag = "v1.13.0" }
+honey-badger = { git = "https://github.com/getlipa/wild/", tag = "v1.13.0" }
+graphql = { git = "https://github.com/getlipa/wild/", tag = "v1.13.0" }
 perro = { git = "https://github.com/getlipa/perro", tag = "v1.1.0" }
 
 breez-sdk-core = { git = "https://github.com/breez/breez-sdk", tag = "0.2.5" }
diff --git a/examples/3l-node/cli.rs b/examples/3l-node/cli.rs
@@ -607,6 +607,7 @@ fn list_offers(node: &LightningNode) -> Result<(), String> {
                 topup_value_minor_units,
                 exchange_fee_minor_units,
                 exchange_fee_rate_permyriad,
+                error,
             } => {
                 println!("                   ID:    {id}");
                 println!(
@@ -628,6 +629,10 @@ fn list_offers(node: &LightningNode) -> Result<(), String> {
                     "             Exchange at: {}",
                     exchanged_at.format("%d/%m/%Y %T UTC"),
                 );
+
+                if let Some(e) = error {
+                    println!("             Failure reason: {:?}", e);
+                }
             }
         }
         println!("      Status:             {:?}", offer.status);
@@ -709,14 +714,15 @@ fn offer_to_string(offer: Option<OfferKind>) -> String {
             topup_value_minor_units,
             exchange_fee_minor_units,
             exchange_fee_rate_permyriad,
+            ..
         }) => {
             let updated_at: DateTime<Utc> = updated_at.into();
             format!(
 				"Pocket exchange ({id}) of {:.2} {currency_code} at {} at rate {rate} SATS per {currency_code}, fee was {:.2}% or {:.2} {currency_code}",
 				topup_value_minor_units as f64 / 100f64,
 				updated_at.format("%d/%m/%Y %T UTC"),
 				exchange_fee_rate_permyriad as f64 / 100f64,
-				exchange_fee_minor_units as f64 / 100f64
+				exchange_fee_minor_units as f64 / 100f64,
 			)
         }
         None => "None".to_string(),
diff --git a/src/data_store.rs b/src/data_store.rs
@@ -1,9 +1,10 @@
 use crate::errors::Result;
 use crate::fund_migration::MigrationStatus;
 use crate::migrations::migrate;
-use crate::{ExchangeRate, OfferKind, TzConfig, UserPreferences};
+use crate::{ExchangeRate, OfferKind, PocketOfferError, TzConfig, UserPreferences};
 
 use chrono::{DateTime, Utc};
+use crow::{PermanentFailureCode, TemporaryFailureCode};
 use perro::MapToError;
 use rusqlite::Connection;
 use rusqlite::Row;
@@ -66,13 +67,14 @@ impl DataStore {
             topup_value_minor_units,
             exchange_fee_minor_units,
             exchange_fee_rate_permyriad,
+            error,
         }) = offer
         {
             let exchanged_at: DateTime<Utc> = updated_at.into();
             tx.execute(
             "\
-                INSERT INTO offers (payment_hash, pocket_id, fiat_currency, rate, exchanged_at, topup_value_minor_units, exchange_fee_minor_units, exchange_fee_rate_permyriad)\
-                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)\
+                INSERT INTO offers (payment_hash, pocket_id, fiat_currency, rate, exchanged_at, topup_value_minor_units, exchange_fee_minor_units, exchange_fee_rate_permyriad, error)\
+                VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)\
                 ",
         (
                     payment_hash,
@@ -82,7 +84,8 @@ impl DataStore {
                     &exchanged_at,
                     topup_value_minor_units,
                     exchange_fee_minor_units,
-                    exchange_fee_rate_permyriad
+                    exchange_fee_rate_permyriad,
+                    from_offer_error(error)
                 ),
             )
             .map_to_invalid_input("Failed to add new incoming pocket offer to offers db")?;
@@ -99,7 +102,7 @@ impl DataStore {
                 " \
             SELECT timezone_id, timezone_utc_offset_secs, payments.fiat_currency, h.rate, h.updated_at,  \
             o.pocket_id, o.fiat_currency, o.rate, o.exchanged_at, o.topup_value_minor_units, \
-			o.exchange_fee_minor_units, o.exchange_fee_rate_permyriad \
+			o.exchange_fee_minor_units, o.exchange_fee_rate_permyriad, o.error \
             FROM payments \
             LEFT JOIN exchange_rates_history h on payments.exchange_rates_history_snaphot_id=h.snapshot_id \
                 AND payments.fiat_currency=h.fiat_currency \
@@ -262,6 +265,7 @@ fn offer_kind_from_row(row: &Row) -> rusqlite::Result<Option<OfferKind>> {
                 topup_value_minor_units,
                 exchange_fee_minor_units,
                 exchange_fee_rate_permyriad,
+                error: to_offer_error(row.get(12)?),
             }))
         }
         None => Ok(None),
@@ -293,13 +297,80 @@ fn local_payment_data_from_row(row: &Row) -> rusqlite::Result<LocalPaymentData>
     })
 }
 
+pub fn from_offer_error(error: Option<PocketOfferError>) -> Option<String> {
+    error.map(|e| {
+        match e {
+            PocketOfferError::TemporaryFailure { code } => match code {
+                TemporaryFailureCode::NoRoute => "no_route".to_string(),
+                TemporaryFailureCode::InvoiceExpired => "invoice_expired".to_string(),
+                TemporaryFailureCode::Unexpected => "error".to_string(),
+                TemporaryFailureCode::Unknown { msg } => msg,
+            },
+            PocketOfferError::PermanentFailure { code } => match code {
+                PermanentFailureCode::ThresholdExceeded => "threshold_exceeded".to_string(),
+                PermanentFailureCode::OrderInactive => "order_inactive".to_string(),
+                PermanentFailureCode::CompaniesUnsupported => "companies_unsupported".to_string(),
+                PermanentFailureCode::CountryUnsupported => "country_unsupported".to_string(),
+                PermanentFailureCode::OtherRiskDetected => "other_risk_detected".to_string(),
+                PermanentFailureCode::CustomerRequested => "customer_requested".to_string(),
+                PermanentFailureCode::AccountNotMatching => "account_not_matching".to_string(),
+                PermanentFailureCode::PayoutExpired => "payout_expired".to_string(),
+            },
+        }
+        .to_string()
+    })
+}
+
+pub fn to_offer_error(code: Option<String>) -> Option<PocketOfferError> {
+    code.map(|c| match &*c {
+        "no_route" => PocketOfferError::TemporaryFailure {
+            code: TemporaryFailureCode::NoRoute,
+        },
+        "invoice_expired" => PocketOfferError::TemporaryFailure {
+            code: TemporaryFailureCode::InvoiceExpired,
+        },
+        "error" => PocketOfferError::TemporaryFailure {
+            code: TemporaryFailureCode::Unexpected,
+        },
+        "threshold_exceeded" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::ThresholdExceeded,
+        },
+        "order_inactive" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::OrderInactive,
+        },
+        "companies_unsupported" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::CompaniesUnsupported,
+        },
+        "country_unsupported" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::CountryUnsupported,
+        },
+        "other_risk_detected" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::OtherRiskDetected,
+        },
+        "customer_requested" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::CustomerRequested,
+        },
+        "account_not_matching" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::AccountNotMatching,
+        },
+        "payout_expired" => PocketOfferError::PermanentFailure {
+            code: PermanentFailureCode::PayoutExpired,
+        },
+        e => PocketOfferError::TemporaryFailure {
+            code: TemporaryFailureCode::Unknown { msg: e.to_string() },
+        },
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use crate::config::TzConfig;
     use crate::data_store::DataStore;
     use crate::fund_migration::MigrationStatus;
     use crate::{ExchangeRate, OfferKind, UserPreferences};
 
+    use crow::TemporaryFailureCode;
+    use crow::TopupError::TemporaryFailure;
     use std::fs;
     use std::thread::sleep;
     use std::time::{Duration, SystemTime};
@@ -342,6 +413,22 @@ mod tests {
             topup_value_minor_units: 51245,
             exchange_fee_minor_units: 123,
             exchange_fee_rate_permyriad: 50,
+            error: Some(TemporaryFailure {
+                code: TemporaryFailureCode::NoRoute,
+            }),
+        };
+
+        let offer_kind_no_error = OfferKind::Pocket {
+            id: "id".to_string(),
+            exchange_rate: ExchangeRate {
+                currency_code: "EUR".to_string(),
+                rate: 5123,
+                updated_at: SystemTime::now(),
+            },
+            topup_value_minor_units: 51245,
+            exchange_fee_minor_units: 123,
+            exchange_fee_rate_permyriad: 50,
+            error: None,
         };
 
         data_store
@@ -362,11 +449,20 @@ mod tests {
             .store_payment_info(
                 "hash - no offer",
                 user_preferences.clone(),
-                exchange_rates,
+                exchange_rates.clone(),
                 None,
             )
             .unwrap();
 
+        data_store
+            .store_payment_info(
+                "hash - no error",
+                user_preferences.clone(),
+                exchange_rates,
+                Some(offer_kind_no_error.clone()),
+            )
+            .unwrap();
+
         assert!(data_store
             .retrieve_payment_info("non existent hash")
             .unwrap()
@@ -398,6 +494,12 @@ mod tests {
             user_preferences.fiat_currency
         );
         assert_eq!(local_payment_data.exchange_rate.rate, 4123);
+
+        let local_payment_data = data_store
+            .retrieve_payment_info("hash - no error")
+            .unwrap()
+            .unwrap();
+        assert_eq!(local_payment_data.offer.unwrap(), offer_kind_no_error);
     }
 
     #[test]
diff --git a/src/lib.rs b/src/lib.rs
@@ -51,6 +51,7 @@ pub use crate::recovery::recover_lightning_node;
 use crate::secret::Secret;
 use crate::task_manager::{TaskManager, TaskPeriods};
 use crate::util::unix_timestamp_to_system_time;
+pub use crow::{PermanentFailureCode, TemporaryFailureCode};
 
 use bip39::{Language, Mnemonic};
 use bitcoin::hashes::hex::ToHex;
@@ -63,7 +64,7 @@ use breez_sdk_core::{
     OpeningFeeParams, PaymentDetails, PaymentStatus, PaymentTypeFilter, SweepRequest,
 };
 use cipher::generic_array::typenum::U32;
-use crow::{CountryCode, LanguageCode, OfferManager, TopupInfo, TopupStatus};
+use crow::{CountryCode, LanguageCode, OfferManager, TopupError, TopupInfo, TopupStatus};
 use data_store::DataStore;
 use email_address::EmailAddress;
 use honey_badger::secrets::{generate_keypair, KeyPair};
@@ -206,6 +207,8 @@ pub enum OfferStatus {
     SETTLED,
 }
 
+pub type PocketOfferError = TopupError;
+
 #[derive(PartialEq, Eq, Debug, Clone)]
 pub enum OfferKind {
     /// An offer related to a topup using the Pocket exchange
@@ -221,6 +224,8 @@ pub enum OfferKind {
         exchange_fee_minor_units: u64,
         /// The rate of the fee expressed in permyriad (e.g. 1.5% would be 150)
         exchange_fee_rate_permyriad: u16,
+        /// The optional error that might occurred in the offer process
+        error: Option<PocketOfferError>,
     },
 }
 
@@ -1097,6 +1102,7 @@ fn to_offer(topup_info: TopupInfo, current_rate: &Option<ExchangeRate>) -> Offer
             topup_value_minor_units: topup_info.topup_value_minor_units,
             exchange_fee_minor_units: topup_info.exchange_fee_minor_units,
             exchange_fee_rate_permyriad: topup_info.exchange_fee_rate_permyriad,
+            error: topup_info.error,
         },
         amount: (topup_info.amount_sat * 1000).to_amount_down(current_rate),
         lnurlw: topup_info.lnurlw,
diff --git a/src/lipalightninglib.udl b/src/lipalightninglib.udl
@@ -265,14 +265,46 @@ dictionary OfferInfo {
     OfferStatus status;
 };
 
+enum PermanentFailureCode {
+    "ThresholdExceeded",
+    "OrderInactive",
+    "CompaniesUnsupported",
+    "CountryUnsupported",
+    "OtherRiskDetected",
+    "CustomerRequested",
+    "AccountNotMatching",
+    "PayoutExpired",
+};
+
+[Enum]
+interface TemporaryFailureCode {
+    NoRoute();
+    InvoiceExpired();
+    Unexpected();
+    Unknown(
+        string msg
+    );
+};
+
+[Enum]
+interface PocketOfferError {
+    TemporaryFailure(
+        TemporaryFailureCode code
+    );
+    PermanentFailure(
+        PermanentFailureCode code
+    );
+};
+
 [Enum]
 interface OfferKind {
     Pocket(
         string id,
         ExchangeRate exchange_rate,
         u64 topup_value_minor_units,
         u64 exchange_fee_minor_units,
-        u16 exchange_fee_rate_permyriad
+        u16 exchange_fee_rate_permyriad,
+        PocketOfferError? error
     );
 };
 
diff --git a/src/migrations.rs b/src/migrations.rs
@@ -50,6 +50,9 @@ const MIGRATION_02_FUNDS_MIGRATION_STATUS: &str = "
     VALUES (0);
 ";
 
+const MIGRATION_03_OFFER_ERROR_MESSAGE: &str = "
+    ALTER TABLE offers ADD COLUMN error TEXT NULL;
+";
 pub(crate) fn migrate(conn: &mut Connection) -> Result<()> {
     migrations()
         .to_latest(conn)
@@ -60,6 +63,7 @@ fn migrations() -> Migrations<'static> {
     Migrations::new(vec![
         M::up(MIGRATION_01_INIT),
         M::up(MIGRATION_02_FUNDS_MIGRATION_STATUS),
+        M::up(MIGRATION_03_OFFER_ERROR_MESSAGE),
     ])
 }
 
