wip

Author: 0xAlunara

apps/main/src/llamalend/features/manage-soft-liquidation/ManageSoftLiquidation.stories.tsx

@@ -17,13 +17,13 @@ const collateralToRecover: ClosePositionProps['collateralToRecover'] = [
     symbol: 'ETH',
     address: ethAddress,
     amount: '26539422',
-    usd: '638000',
+    usd: 638000,
   },
   {
     symbol: 'crvUSD',
     address: CRVUSD_ADDRESS,
     amount: '12450',
-    usd: '12450',
+    usd: 12450,
   },
 ]
 

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/can-close.ts

@@ -0,0 +1,35 @@
+import { decimal } from '@ui-kit/utils'
+import type { ClosePositionProps } from '..'
+import type { UserState, UserBalances } from '../types'
+
+type Props = {
+  userState: Pick<UserState, 'debt' | 'stablecoin'> | undefined
+  userBalances: UserBalances | undefined
+}
+
+/**
+ * Determines if a user can close their position and how much additional
+ * stablecoin is required. Applies a 0.01% safety buffer to account for
+ * potential contract execution edge cases where exact balance matching
+ * might fail due to rounding or state changes between transaction
+ * submission and execution.
+ *
+ * @returns Object containing required amount to close and missing amount
+ * @example
+ * ```typescript
+ * const result = canClose({
+ *   userState: { debt: '100', stablecoin: '50' },
+ *   userBalances: { stablecoin: '60' }
+ * })
+ * // result: { requiredToClose: 50.005, missing: 9.995 }
+ * ```
+ */
+export function checkCanClose({ userState, userBalances }: Props): ClosePositionProps['canClose'] {
+  const { debt = '0', stablecoin = '0' } = userState ?? {}
+  const { borrowed = '0' } = userBalances ?? {}
+
+  const requiredToClose = (+debt - +stablecoin) * 1.0001
+  const missing = Math.max(0, requiredToClose - +borrowed)
+
+  return { requiredToClose: decimal(requiredToClose), missing: decimal(missing) }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/collateral-info.ts

@@ -0,0 +1,22 @@
+import { getTokens } from '@/llamalend/llama.utils'
+import type { ActionInfosProps } from '..'
+import type { UserState, Market } from '../types'
+import { parseFloatOptional } from './float'
+
+type Props = {
+  market: Market | undefined
+  userState: Pick<UserState, 'collateral' | 'stablecoin' | 'debt'> | undefined
+}
+
+export function getCollateralInfo({ market, userState }: Props): ActionInfosProps['collateral'] {
+  const { collateral } = userState ?? {}
+  const amount = parseFloatOptional(collateral)
+  const { symbol } = (market && getTokens(market))?.collateralToken || {}
+  const borrowed = (amount && symbol && { symbol, amount }) || undefined
+
+  return {
+    borrowed,
+    leverage: undefined, // I don't know yet how to determine it so it's not available for now
+    assetsToWithdraw: undefined, // Not sure what the point is atm, same as 'collateral' action info in loan group?
+  }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/collateral-to-recover.ts

@@ -0,0 +1,53 @@
+import { decimal, type Address } from '@ui-kit/utils'
+import type { ClosePositionProps } from '..'
+import type { UserState } from '../types'
+
+type Token = { symbol: string; address: Address; usdRate: number | undefined }
+
+type Props = {
+  stablecoinToken: Token | undefined
+  collateralToken: Token | undefined
+  userState: Pick<UserState, 'collateral' | 'stablecoin' | 'debt'> | undefined
+}
+
+/**
+ * Calculates the recoverable collateral when closing a position
+ *
+ * This function determines what assets a user can recover when closing their position:
+ * 1. Any remaining collateral tokens after position closure
+ * 2. Excess stablecoin (if stablecoin balance exceeds outstanding debt)
+ *
+ * @returns Array of recoverable token objects
+ */
+export function getCollateralToRecover({
+  stablecoinToken,
+  collateralToken,
+  userState,
+}: Props): ClosePositionProps['collateralToRecover'] {
+  const { collateral, debt, stablecoin } = userState ?? {}
+
+  const result: ReturnType<typeof getCollateralToRecover> = []
+
+  // Add collateral tokens if user has any remaining after position closure
+  if (collateral && collateralToken && +collateral > 0) {
+    result.push({
+      symbol: collateralToken.symbol,
+      address: collateralToken.address,
+      amount: collateral,
+      usd: +collateral * (collateralToken.usdRate ?? 0),
+    })
+  }
+
+  // Add excess stablecoin (stablecoin balance minus outstanding debt) if positive
+  const stablecoinBalance = (stablecoin && debt && +stablecoin - +debt) || 0
+  if (stablecoin && stablecoinToken && stablecoinBalance > 0) {
+    result.push({
+      symbol: stablecoinToken.symbol,
+      address: stablecoinToken.address,
+      amount: decimal(stablecoinBalance),
+      usd: stablecoinBalance * (stablecoinToken.usdRate ?? 0),
+    })
+  }
+
+  return result
+}

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/debt-token.ts

@@ -0,0 +1,28 @@
+import { getTokens } from '@/llamalend/llama.utils'
+import type { ClosePositionProps } from '..'
+import type { UserState, Market } from '../types'
+
+type Props = {
+  market: Market | undefined
+  userState: Pick<UserState, 'debt'> | undefined
+}
+
+/**
+ * Extracts debt token information for a user's position in a Llamma market.
+ *
+ * @returns Debt token object.
+ */
+export function getDebtToken({ market, userState }: Props): ClosePositionProps['debtToken'] {
+  const { debt } = userState ?? {}
+  const { borrowToken } = (market && getTokens(market)) || {}
+
+  if (!borrowToken || !borrowToken.address || debt == null) {
+    return undefined
+  }
+
+  return {
+    symbol: borrowToken.symbol,
+    address: borrowToken.address,
+    amount: debt,
+  }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/float.ts

@@ -0,0 +1,8 @@
+/**
+ * Parses a string to a float, returning undefined if the input is null/undefined,
+ * or 0 if the parsing fails.
+ *
+ * @param x - The string to parse as a float
+ * @returns The parsed float value, undefined if input is null/undefined, or 0 if parsing fails
+ */
+export const parseFloatOptional = (x?: string) => (x == null ? undefined : parseFloat(x) || 0)

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/health-info.ts

@@ -0,0 +1,14 @@
+import type { ActionInfosProps } from '..'
+import type { UserLoanDetails } from '../types'
+
+type Props = {
+  userLoanDetails: Pick<UserLoanDetails, 'healthFull'> | undefined
+}
+
+/** Calculates the current health of a user's loan position */
+export function getHealthInfo({ userLoanDetails }: Props): ActionInfosProps['health'] {
+  const { healthFull: healthFullRaw } = userLoanDetails ?? {}
+  const healthFull = isNaN(parseFloat(healthFullRaw ?? '')) ? 0 : parseFloat(healthFullRaw ?? '')
+
+  return { current: healthFull }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/index.ts

@@ -0,0 +1,7 @@
+export { getDebtToken } from './debt-token'
+export { getCollateralToRecover } from './collateral-to-recover'
+export { checkCanClose } from './can-close'
+export { getHealthInfo } from './health-info'
+export { getLoanInfo } from './loan-info'
+export { getCollateralInfo } from './collateral-info'
+export * from './float'

apps/main/src/llamalend/features/manage-soft-liquidation/helpers/loan-info.ts

@@ -0,0 +1,40 @@
+import { getTokens } from '@/llamalend/llama.utils'
+import type { ActionInfosProps } from '..'
+import type { LoanParameters, Market, UserState } from '../types'
+import type { getCollateralToRecover } from './collateral-to-recover'
+import { parseFloatOptional } from './float'
+
+type Props = {
+  market: Market | undefined
+  loanParameters: LoanParameters | undefined
+  userState: Pick<UserState, 'collateral' | 'stablecoin' | 'debt'> | undefined
+  collateralToRecover: ReturnType<typeof getCollateralToRecover> | undefined
+}
+
+export function getLoanInfo({
+  market,
+  loanParameters,
+  userState,
+  collateralToRecover,
+}: Props): ActionInfosProps['loan'] {
+  const { stablecoin } = userState ?? {}
+  const amount = parseFloatOptional(stablecoin)
+  const { symbol } = (market && getTokens(market))?.borrowToken || {}
+  const debt = (amount && symbol && { symbol, amount }) || undefined
+
+  const borrowRate = loanParameters
+    ? {
+        current: parseFloat(loanParameters.rate),
+        next: parseFloatOptional(loanParameters.future_rate),
+      }
+    : undefined
+
+  return {
+    borrowRate,
+    debt,
+    ltv: undefined, // I don't know yet how to determine it so it's not available for now
+    collateral: (collateralToRecover ?? []).filter(
+      (item): item is typeof item & { amount: number } => item.amount != null && +item.amount > 0,
+    ),
+  }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/index.tsx

@@ -1,3 +1,4 @@
 export { ManageSoftLiquidation, type Props } from './ui/ManageSoftLiquidation'
 export type { Props as ImproveHealthProps } from './ui/tabs/ImproveHealth'
 export type { Props as ClosePositionProps } from './ui/tabs/ClosePosition'
+export type { Props as ActionInfosProps } from './ui/ActionInfos'