wip

Author: 0xAlunara

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

@@ -0,0 +1,34 @@
+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 { stablecoin: stablecoinBalance = '0' } = userBalances ?? {}
+
+  const requiredToClose = (parseFloat(debt) - parseFloat(stablecoin)) * 1.0001
+  const missing = Math.max(0, requiredToClose - parseFloat(stablecoinBalance))
+
+  return { requiredToClose, missing }
+}

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

@@ -0,0 +1,22 @@
+import type { ActionInfosProps } from '..'
+import type { UserState, Market } from '../types'
+import { parseFloatOptional } from './float'
+import { getTokens } from './market'
+
+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))?.collateral || {}
+  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,54 @@
+import 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
+  const collateralBalance = (collateral && parseFloat(collateral)) || 0
+  if (collateral && collateralToken && collateralBalance > 0) {
+    result.push({
+      symbol: collateralToken.symbol,
+      address: collateralToken.address,
+      amount: collateralBalance,
+      usd: collateralBalance * (collateralToken.usdRate ?? 0),
+    })
+  }
+
+  // Add excess stablecoin (stablecoin balance minus outstanding debt) if positive
+  const stablecoinBalance = (stablecoin && debt && parseFloat(stablecoin) - parseFloat(debt)) || 0
+  if (stablecoin && stablecoinToken && stablecoinBalance > 0) {
+    result.push({
+      symbol: stablecoinToken.symbol,
+      address: stablecoinToken.address,
+      amount: 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 type { ClosePositionProps } from '..'
+import { getTokens } from '../helpers/market'
+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 { stablecoin } = (market && getTokens(market)) || {}
+
+  if (!stablecoin || !stablecoin.address || debt == null) {
+    return undefined
+  }
+
+  return {
+    symbol: stablecoin.symbol,
+    address: stablecoin.address,
+    amount: parseFloat(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,8 @@
+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'
+export * from './market'

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

@@ -0,0 +1,40 @@
+import type { ActionInfosProps } from '..'
+import type { LoanParameters, Market, UserState } from '../types'
+import type { getCollateralToRecover } from './collateral-to-recover'
+import { parseFloatOptional } from './float'
+import { getTokens } from './market'
+
+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))?.stablecoin || {}
+  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/helpers/market.ts

@@ -0,0 +1,38 @@
+import type { LendMarketTemplate } from '@curvefi/llamalend-api/lib/lendMarkets'
+import type { MintMarketTemplate } from '@curvefi/llamalend-api/lib/mintMarkets'
+import type { Address } from '@ui-kit/utils'
+import type { Market } from '../types'
+
+/** Type guard to check if a market is a MintMarketTemplate */
+export function isMintMarket(market: Market): market is MintMarketTemplate {
+  return 'coins' in market
+}
+
+/** Type guard to check if a market is a LendMarketTemplate */
+export function isLendMarket(market: Market): market is LendMarketTemplate {
+  return 'borrowed_token' in market
+}
+
+/**
+ * Extracts token information from a market template
+ * @param market - The market template
+ * @returns Object containing stablecoin and collateral token details with symbol, address, and decimals
+ */
+export function getTokens(market: Market) {
+  const [stablecoinSymbol, collateralSymbol] = isMintMarket(market) ? market.coins : [market.borrowed_token.symbol]
+  const [stablecoinAddress, collateralAddress] = market?.coinAddresses ?? [undefined, undefined]
+  const [stablecoinDecimals, collateralDecimals] = market?.coinDecimals ?? [undefined, undefined]
+
+  return {
+    stablecoin: {
+      symbol: stablecoinSymbol,
+      address: stablecoinAddress as Address,
+      decimals: stablecoinDecimals,
+    },
+    collateral: {
+      symbol: collateralSymbol,
+      address: collateralAddress as Address,
+      decimals: collateralDecimals,
+    },
+  }
+}

apps/main/src/llamalend/features/manage-soft-liquidation/hooks/mutations/useClosePosition.ts

@@ -0,0 +1,52 @@
+import apiLending from '@/lend/lib/apiLending'
+import { useLlammaMutation } from '@/llamalend/hooks/mutations/useLlammaMutation'
+import networks from '@/loan/networks'
+import type { ChainId } from '@/loan/types/loan.types'
+import type { LendMarketTemplate } from '@curvefi/llamalend-api/lib/lendMarkets'
+import type { MintMarketTemplate } from '@curvefi/llamalend-api/lib/mintMarkets'
+import { notify } from '@ui-kit/features/connect-wallet'
+import { useUserProfileStore } from '@ui-kit/features/user-profile'
+
+const handlers = {
+  pendingMessage: 'Closing position',
+  onSuccess: ({ hash }: { hash?: string }) => hash && notify('Position closed', 'success'),
+  onError: (error: Error) => notify(error.message, 'error'),
+}
+
+/**
+ * Hook for closing a mint position by liquidating the user's position
+ * @param market - The mint market template to close the position for
+ * @returns Mutation object for closing the position
+ */
+export function useClosePositionMint({ market }: { market: MintMarketTemplate | undefined }) {
+  const maxSlippage = useUserProfileStore((state) => state.maxSlippage.crypto)
+
+  return useLlammaMutation({
+    market,
+    mutationFn: async (vars: void, { provider, curve, market }) => {
+      const chainId = curve.chainId as ChainId
+      const liquidateFn = networks[chainId].api.loanLiquidate.liquidate
+
+      return liquidateFn(provider, market, maxSlippage)
+    },
+    ...handlers,
+  })
+}
+
+const { loanSelfLiquidation } = apiLending
+
+/**
+ * Hook for closing a lending position by self-liquidating the user's position
+ * @param market - The lend market template to close the position for
+ * @returns Mutation object for closing the position
+ */
+export function useClosePositionLend({ market }: { market: LendMarketTemplate | undefined }) {
+  const maxSlippage = useUserProfileStore((state) => state.maxSlippage.crypto)
+
+  return useLlammaMutation({
+    market,
+    mutationFn: async (vars: void, { provider, market }) =>
+      loanSelfLiquidation.selfLiquidate(provider, market, maxSlippage),
+    ...handlers,
+  })
+}