fix: PnL miscalculation for non-LPN collateral and RepayDialog crash

PnL: downpayment amount (LS_cltr_amnt_stable) uses collateral asset
decimals, not LPN decimals. When collateral is BTC (8 decimals) but
code divided by 10^6 (USDC), the downpayment was inflated ~100x,
producing wildly wrong PnL values (e.g. -$990K instead of -$3K).

RepayDialog: totalBalances.find() matched by ibcData across all
protocols, returning a currency from a protocol without prices in
pricesStore, causing "Cannot read properties of undefined" crash.
Replaced with direct wallet balance lookup on the protocol-specific
repayment currency.

Author: kostovster

backend/src/handlers/leases.rs

@@ -160,8 +160,10 @@ pub struct LeaseOpeningStateInfo {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LeaseEtlData {
-    /// Downpayment amount in USD
+    /// Downpayment amount (LS_cltr_amnt_stable: asset_micro_units × price)
     pub downpayment_amount: Option<String>,
+    /// Collateral symbol (e.g., "USDC_NOBLE" or "ALL_BTC") — determines downpayment decimals
+    pub collateral_symbol: Option<String>,
     /// Opening price per asset
     pub price: Option<String>,
     /// LPN price at opening (for short positions)
@@ -738,6 +740,7 @@ async fn fetch_lease_info(
     // Note: Some fields are at the top level of EtlLeaseOpening, not inside lease
     let etl_info = etl_data.as_ref().map(|d| LeaseEtlData {
         downpayment_amount: d.lease.downpayment_amount.clone(),
+        collateral_symbol: d.lease.collateral_symbol.clone(),
         // Opening price is inside lease.opening_price (was LS_opening_price)
         price: d.lease.opening_price.clone(),
         // lpn_price and fee are at the top level, not inside lease
@@ -1120,7 +1123,7 @@ fn parse_opened_status(status: &Option<serde_json::Value>) -> Option<LeaseInProg
 /// Where:
 ///   - assetValueUsd = Dec(amount, assetDecimals) * assetPrice
 ///   - totalDebtUsd = Dec(debtTotal, lpnDecimals) * lpnPrice
-///   - downPayment = Dec(etl.downpayment_amount, lpnDecimals)
+///   - downPayment = Dec(etl.downpayment_amount, collateralDecimals)
 ///   - fee = Dec(etl.fee, assetDecimals)
 ///   - repaymentValue = parseFloat(etl.repayment_value) (already formatted)
 fn calculate_pnl(
@@ -1163,7 +1166,20 @@ fn calculate_pnl(
     let debt_total: f64 = total_debt.parse().ok()?;
     let total_debt_usd = (debt_total / 10_f64.powi(lpn_decimals)) * lpn_price;
 
-    // Parse ETL data: downpayment uses LPN decimals
+    // Parse ETL data: downpayment uses collateral asset decimals.
+    // LS_cltr_amnt_stable = asset_micro_units × price, so the decimal factor
+    // comes from the collateral asset, not LPN (they differ when the user pays
+    // the downpayment in a non-LPN asset like BTC).
+    let cltr_decimals = etl
+        .lease
+        .collateral_symbol
+        .as_deref()
+        .and_then(|cltr_ticker| {
+            let cltr_key = format!("{}@{}", cltr_ticker, protocol);
+            currencies.currencies.get(&cltr_key).map(|c| c.decimal_digits as i32)
+        })
+        .unwrap_or(lpn_decimals);
+
     // None legitimately means 0 (no downpayment recorded); parse failure is a data issue
     let downpayment_raw: f64 = match etl.lease.downpayment_amount.as_deref() {
         Some(s) => s.parse().unwrap_or_else(|_| {
@@ -1175,7 +1191,7 @@ fn calculate_pnl(
         }),
         None => 0.0,
     };
-    let downpayment = downpayment_raw / 10_f64.powi(lpn_decimals);
+    let downpayment = downpayment_raw / 10_f64.powi(cltr_decimals);
 
     // Fee uses asset decimals (matching frontend behavior)
     let fee_raw: f64 = match etl.fee.as_deref() {
@@ -1646,13 +1662,22 @@ mod tests {
     }
 
     fn make_etl(downpayment: &str, fee: &str, repayment_value: &str) -> EtlLeaseOpening {
+        make_etl_with_collateral(downpayment, fee, repayment_value, None)
+    }
+
+    fn make_etl_with_collateral(
+        downpayment: &str,
+        fee: &str,
+        repayment_value: &str,
+        collateral_symbol: Option<&str>,
+    ) -> EtlLeaseOpening {
         EtlLeaseOpening {
             lease: EtlLeaseInfo {
                 timestamp: None,
                 downpayment_amount: Some(downpayment.to_string()),
                 loan_amount: None,
                 lease_position_ticker: None,
-                collateral_symbol: None,
+                collateral_symbol: collateral_symbol.map(|s| s.to_string()),
                 opening_price: None,
                 history: None,
             },
@@ -1857,6 +1882,56 @@ mod tests {
         assert!(result.is_none());
     }
 
+    #[test]
+    fn test_calculate_pnl_btc_collateral() {
+        // Reproduces the bug: user pays downpayment in BTC, not USDC.
+        // LS_cltr_amnt_stable = asset_micro × price = 13200000 × 75583.85 ≈ 997706865842
+        // Correct: divide by 10^8 (BTC decimals) = $9977.07
+        // Bug:     divide by 10^6 (USDC decimals) = $997706.87 (100x too large)
+        //
+        // BTC at $90,000, holding 0.46 BTC = $41,400
+        // Debt: 14974 USDC at $1.00 = $14,974
+        // Downpayment: 0.132 BTC at $75,583.85 → LS_cltr_amnt_stable = 997706865842
+        //   Correct downpayment = 997706865842 / 10^8 = $9977.07
+        // Repayment: $1000
+        // PnL = 41400 - 14974 - 9977.07 + 0 - 1000 = $15448.93
+        // PnL% = 15448.93 / (9977.07 + 1000) * 100 = 140.77%
+        let opened = make_opened("ALL_BTC", "46000000", "USDC_NOBLE"); // 0.46 BTC
+        let etl = make_etl_with_collateral(
+            "997706865842", // LS_cltr_amnt_stable (asset_micro × price)
+            "0",
+            "1000",
+            Some("ALL_BTC"), // collateral is BTC, not USDC
+        );
+        let (prices, currencies) = make_prices_and_currencies("90000", "1.0");
+
+        let result = calculate_pnl(
+            "TEST-PROTOCOL",
+            &opened,
+            "14974000000", // ~14974 USDC debt
+            Some(&etl),
+            Some(&prices),
+            Some(&currencies),
+        );
+
+        let pnl = result.unwrap();
+        let amount: f64 = pnl.amount.parse().unwrap();
+        let percent: f64 = pnl.percent.parse().unwrap();
+        // With correct BTC decimals (8): downpayment = $9977.07
+        // PnL ≈ $15448.93, PnL% ≈ 140.77%
+        assert!(
+            (amount - 15448.93).abs() < 1.0,
+            "PnL amount should be ~$15449 but got {}",
+            amount
+        );
+        assert!(
+            (percent - 140.77).abs() < 1.0,
+            "PnL percent should be ~140.8% but got {}",
+            percent
+        );
+        assert!(pnl.pnl_positive);
+    }
+
     #[test]
     fn test_enrich_history_action_liquidation_with_cause() {
         assert_eq!(

src/common/api/types/leases.ts

@@ -84,8 +84,10 @@ export interface LeaseOpeningStateInfo {
 }
 
 export interface LeaseEtlData {
-  /** Downpayment amount in USD */
+  /** Downpayment amount (LS_cltr_amnt_stable: asset_micro_units × price) */
   downpayment_amount?: string;
+  /** Collateral symbol (e.g., "USDC_NOBLE" or "ALL_BTC") — determines downpayment decimals */
+  collateral_symbol?: string;
   /** Opening price per asset */
   price?: string;
   /** LPN price at opening (for short positions) */

src/common/utils/LeaseCalculator.ts

@@ -118,11 +118,17 @@ export class LeaseCalculator {
     const { health, healthStatus } = this.calculateHealth(lease, assetValueUsd, totalDebtUsd);
 
     // Parse ETL data (needed for PnL calculation)
-    // Note: downpayment uses LPN decimals, fee uses asset decimals (to match production)
+    // Downpayment uses collateral asset decimals (LS_cltr_amnt_stable = asset_micro × price),
+    // fee uses leased asset decimals.
+    const collateralDecimals = lease.etl_data?.collateral_symbol
+      ? (this.currencyProvider.getCurrency(lease.etl_data.collateral_symbol, protocol)?.decimal_digits ??
+        lpnCurrency?.decimal_digits ??
+        6)
+      : (lpnCurrency?.decimal_digits ?? 6);
     const { downPayment, openingPrice, fee, repaymentValue } = this.parseEtlData(
       lease,
       positionType,
-      lpnCurrency?.decimal_digits ?? 6,
+      collateralDecimals,
       currency?.decimal_digits ?? 8
     );
 
@@ -365,13 +371,13 @@ export class LeaseCalculator {
 
   /**
    * Parse ETL data from lease
-   * @param lpnDecimals - decimals for LPN currency (used for downpayment)
-   * @param assetDecimals - decimals for the leased asset (used for fee, matching production behavior)
+   * @param collateralDecimals - decimals for the collateral asset (used for downpayment)
+   * @param assetDecimals - decimals for the leased asset (used for fee)
    */
   parseEtlData(
     lease: LeaseInfo,
     positionType: string,
-    lpnDecimals: number,
+    collateralDecimals: number,
     assetDecimals: number
   ): {
     downPayment: Dec;
@@ -380,7 +386,7 @@ export class LeaseCalculator {
     repaymentValue: Dec;
   } {
     const downPayment = lease.etl_data?.downpayment_amount
-      ? new Dec(lease.etl_data.downpayment_amount, lpnDecimals)
+      ? new Dec(lease.etl_data.downpayment_amount, collateralDecimals)
       : new Dec(0);
 
     const openingPrice =

src/modules/leases/components/single-lease/RepayDialog.vue

@@ -273,7 +273,7 @@ const balances = computed(() => {
   let repaymentCurrency;
 
   if (positionType === "Short") {
-    // Short: debt is in the underlying asset (e.g. ATOM), use debt.ticker
+    // Short: debt is in LPN (e.g. USDC_NOBLE), use debt.ticker
     const debtTicker = lease.value.debt.ticker;
     repaymentCurrency = configStore.currenciesData![`${debtTicker}@${lease.value.protocol}`];
   } else {
@@ -283,29 +283,10 @@ const balances = computed(() => {
 
   if (!repaymentCurrency) return [];
 
-  // Look for the repayment currency in wallet balances
-  const match = totalBalances.value.find((item) => item.ibcData === repaymentCurrency!.ibcData);
-  if (match) return [match];
-
-  // Always show the currency even with zero balance so the user can see what to repay with
-  const zeroCurrency = { ...repaymentCurrency, balance: { denom: repaymentCurrency.ibcData, amount: "0" } };
-  return [zeroCurrency];
-});
-
-const totalBalances = computed(() => {
-  const assets = [];
-
-  for (const key in configStore.currenciesData ?? {}) {
-    const currency = configStore.currenciesData![key];
-    const c = { ...currency };
-    const item = balancesStore.balances.find((item) => item.denom == currency.ibcData);
-    if (item) {
-      c.balance = item;
-      assets.push(c);
-    }
-  }
-
-  return assets;
+  // Use the protocol-specific currency directly (not a cross-protocol find by ibcData)
+  // to ensure the .key matches the price entry in pricesStore.
+  const walletBalance = balancesStore.balances.find((item) => item.denom === repaymentCurrency!.ibcData);
+  return [{ ...repaymentCurrency, balance: walletBalance ?? { denom: repaymentCurrency.ibcData, amount: "0" } }];
 });
 
 function handleAmountChange(event: string) {