Merge pull request #1735 from curvefi/feat/queries

feat: missing repay queries

Author: DanielSchiavini

apps/main/src/llamalend/features/manage-loan/components/RepayForm.tsx

@@ -11,7 +11,6 @@ import Button from '@mui/material/Button'
 import Stack from '@mui/material/Stack'
 import { useSwitch } from '@ui-kit/hooks/useSwitch'
 import { t } from '@ui-kit/lib/i18n'
-import type { Decimal } from '@ui-kit/utils'
 import { InputDivider } from '../../../widgets/InputDivider'
 import { useRepayForm } from '../hooks/useRepayForm'
 
@@ -46,14 +45,17 @@ export const RepayForm = <ChainId extends IChainId>({
     health,
     prices,
     gas,
-    isAvailable,
+    isDisabled,
     isFull,
     formErrors,
     collateralToken,
     borrowToken,
     params,
     values,
     txHash,
+    expectedBorrowed,
+    routeImage,
+    priceImpact,
   } = useRepayForm({
     market,
     network,
@@ -64,8 +66,6 @@ export const RepayForm = <ChainId extends IChainId>({
 
   const marketRates = useMarketRates(params, isOpen)
 
-  const isDisabled = formErrors.length > 0 || isAvailable.data === false
-
   return (
     <LoanFormWrapper // todo: prevHealth, prevRates, debt, prevDebt
       {...form}
@@ -85,7 +85,7 @@ export const RepayForm = <ChainId extends IChainId>({
             collateralToken,
             borrowToken,
             enabled: isOpen,
-            debtDelta: values.userBorrowed == null ? undefined : (`-${values.userBorrowed}` as Decimal),
+            expectedBorrowed: expectedBorrowed.data?.totalBorrowed,
           })}
           gas={gas}
         />

apps/main/src/llamalend/features/manage-loan/hooks/useLoanToValueFromUserState.ts

@@ -13,10 +13,13 @@ type Params<ChainId extends IChainId> = {
   collateralToken: Token | undefined
   borrowToken: Token | undefined
   enabled: boolean
-  /** Net change applied to on-chain collateral (positive = adding, negative = removing). */
+  /**
+   * Net change applied to on-chain collateral (positive = adding, negative = removing).
+   * TODO: use expectedCollateral from llamalend-js, currently being implemented by @0xPearce
+   * */
   collateralDelta?: Decimal | null
-  /** Net change applied to on-chain debt (positive = increasing, negative = repaying). */
-  debtDelta?: Decimal | null
+  /** Expected new borrowed amount after the loan is updated. */
+  expectedBorrowed?: Decimal | null
 }
 
 /**
@@ -34,7 +37,7 @@ export const useLoanToValueFromUserState = <ChainId extends IChainId>({
   borrowToken,
   enabled,
   collateralDelta,
-  debtDelta,
+  expectedBorrowed,
 }: Params<ChainId>) => {
   const {
     data: userState,
@@ -54,11 +57,9 @@ export const useLoanToValueFromUserState = <ChainId extends IChainId>({
     error: borrowUsdRateError,
   } = useTokenUsdRate({ chainId, tokenAddress: borrowToken?.address }, enabled && !!borrowToken?.address)
 
-  const baseDebt = userState?.debt
   const baseCollateral = userState?.collateral
 
-  const debt = baseDebt == null ? null : new BigNumber(baseDebt).plus(debtDelta ?? '0')
-
+  const debt = expectedBorrowed == null ? null : new BigNumber(expectedBorrowed)
   const collateral = baseCollateral == null ? null : new BigNumber(baseCollateral).plus(collateralDelta ?? '0')
 
   return {

apps/main/src/llamalend/features/manage-loan/hooks/useRepayForm.ts

@@ -15,8 +15,8 @@ import { useRepayIsFull } from '@/llamalend/queries/repay/repay-is-full.query'
 import { useRepayPriceImpact } from '@/llamalend/queries/repay/repay-price-impact.query'
 import { useRepayPrices } from '@/llamalend/queries/repay/repay-prices.query'
 import { useRepayRouteImage } from '@/llamalend/queries/repay/repay-route-image.query'
-import type { RepayFromCollateralParams } from '@/llamalend/queries/validation/manage-loan.types'
-import { repayFormValidationSuite, type RepayForm } from '@/llamalend/queries/validation/manage-loan.validation'
+import type { RepayFromCollateralIsFullParams } from '@/llamalend/queries/validation/manage-loan.types'
+import { type RepayForm, repayFormValidationSuite } from '@/llamalend/queries/validation/manage-loan.validation'
 import type { IChainId as LlamaChainId, INetworkName as LlamaNetworkId } from '@curvefi/llamalend-api/lib/interfaces'
 import { vestResolver } from '@hookform/resolvers/vest'
 import { useDebouncedValue } from '@ui-kit/hooks/useDebounce'
@@ -54,23 +54,32 @@ export const useRepayForm = <ChainId extends LlamaChainId, NetworkName extends L
       stateCollateral: undefined,
       userCollateral: undefined,
       userBorrowed: undefined,
+      isFull: false,
     },
   })
 
   const values = form.watch()
 
   const params = useDebouncedValue(
     useMemo(
-      () =>
-        ({
-          chainId,
-          marketId,
-          userAddress,
-          stateCollateral: values.stateCollateral,
-          userCollateral: values.userCollateral,
-          userBorrowed: values.userBorrowed,
-        }) as RepayFromCollateralParams<ChainId>,
-      [chainId, marketId, userAddress, values.stateCollateral, values.userCollateral, values.userBorrowed],
+      (): RepayFromCollateralIsFullParams<ChainId> => ({
+        chainId,
+        marketId,
+        userAddress,
+        stateCollateral: values.stateCollateral,
+        userCollateral: values.userCollateral,
+        userBorrowed: values.userBorrowed,
+        isFull: values.isFull,
+      }),
+      [
+        chainId,
+        marketId,
+        userAddress,
+        values.stateCollateral,
+        values.userCollateral,
+        values.userBorrowed,
+        values.isFull,
+      ],
     ),
   )
 
@@ -90,9 +99,9 @@ export const useRepayForm = <ChainId extends LlamaChainId, NetworkName extends L
 
   const formErrors = useFormErrors(form.formState)
 
+  useEffect(() => form.setValue('isFull', isFull.data, { shouldValidate: true }), [form, isFull.data])
+
   return {
-    chainId,
-    marketId,
     form,
     values,
     params,
@@ -102,7 +111,7 @@ export const useRepayForm = <ChainId extends LlamaChainId, NetworkName extends L
     bands,
     expectedBorrowed,
     health,
-    isAvailable,
+    isDisabled: !isAvailable.data || formErrors.length > 0,
     isFull,
     priceImpact,
     prices,

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

@@ -20,6 +20,7 @@ export function useImproveHealthTab(params: MarketParams): ImproveHealthProps {
         stateCollateral: '0' as Decimal,
         userCollateral: '0' as Decimal,
         userBorrowed: debt,
+        isFull: false, // todo: implement full repays
       })
     },
     [mutate],

apps/main/src/llamalend/mutations/repay.mutation.ts

@@ -1,18 +1,21 @@
 import { useCallback } from 'react'
 import type { Address, Hex } from 'viem'
+import { useConfig } from 'wagmi'
 import { formatTokenAmounts } from '@/llamalend/llama.utils'
+import { LlamaMarketTemplate } from '@/llamalend/llamalend.types'
 import { type LlammaMutationOptions, useLlammaMutation } from '@/llamalend/mutations/useLlammaMutation'
+import { fetchRepayIsApproved } from '@/llamalend/queries/repay/repay-is-approved.query'
 import {
   type RepayForm,
-  repayFromCollateralValidationSuite,
+  repayFromCollateralIsFullValidationSuite,
 } from '@/llamalend/queries/validation/manage-loan.validation'
 import type { IChainId as LlamaChainId, INetworkName as LlamaNetworkId } from '@curvefi/llamalend-api/lib/interfaces'
 import { LendMarketTemplate } from '@curvefi/llamalend-api/lib/lendMarkets'
 import { t } from '@ui-kit/lib/i18n'
 import { rootKeys } from '@ui-kit/lib/model'
-import type { Decimal } from '@ui-kit/utils'
+import { type Decimal, waitForApproval } from '@ui-kit/utils'
 
-type RepayMutation = { stateCollateral: Decimal; userCollateral: Decimal; userBorrowed: Decimal }
+type RepayMutation = { stateCollateral: Decimal; userCollateral: Decimal; userBorrowed: Decimal; isFull: boolean }
 
 export type RepayOptions = {
   marketId: string | undefined
@@ -22,6 +25,41 @@ export type RepayOptions = {
   userAddress: Address | undefined
 }
 
+const approveRepay = async (market: LlamaMarketTemplate, { userCollateral, userBorrowed, isFull }: RepayMutation) => {
+  if (isFull) {
+    return (await market.fullRepayApprove()) as Hex[]
+  }
+  if (market instanceof LendMarketTemplate) {
+    return (await market.leverage.repayApprove(userCollateral, userBorrowed)) as Hex[]
+  }
+  if (market.leverageV2.hasLeverage()) {
+    return (await market.leverageV2.repayApprove(userCollateral, userBorrowed)) as Hex[]
+  }
+  console.assert(!+userCollateral, `userCollateral should be 0 for non-leverage repay`)
+  return (await market.repayApprove(userBorrowed)) as Hex[]
+}
+
+const repay = async (market: LlamaMarketTemplate, mutation: RepayMutation): Promise<Hex> => {
+  const { stateCollateral, userCollateral, userBorrowed, isFull } = mutation
+  if (isFull) {
+    return (await market.fullRepay()) as Hex
+  }
+
+  if (market instanceof LendMarketTemplate) {
+    await market.leverage.repayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)
+    return (await market.leverage.repay(stateCollateral, userCollateral, userBorrowed)) as Hex
+  }
+
+  if (market.leverageV2.hasLeverage()) {
+    await market.leverageV2.repayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)
+    return (await market.leverageV2.repay(stateCollateral, userCollateral, userBorrowed)) as Hex
+  }
+
+  console.assert(!+stateCollateral, `stateCollateral should be 0 for non-leverage repay`)
+  console.assert(!+userBorrowed, `userBorrowed should be 0 for non-leverage repay`)
+  return (await market.deleverage.repay(userCollateral)) as Hex
+}
+
 export const useRepayMutation = ({
   network,
   network: { chainId },
@@ -30,19 +68,33 @@ export const useRepayMutation = ({
   onReset,
   userAddress,
 }: RepayOptions) => {
+  const config = useConfig()
   const { mutate, mutateAsync, error, data, isPending, isSuccess, reset } = useLlammaMutation<RepayMutation>({
     network,
     marketId,
     mutationKey: [...rootKeys.userMarket({ chainId, marketId, userAddress }), 'repay'] as const,
-    mutationFn: async ({ userCollateral, userBorrowed, stateCollateral }, { market }) => ({
-      hash:
-        market instanceof LendMarketTemplate
-          ? ((await market.leverage.repay(stateCollateral, userCollateral, userBorrowed)) as Hex)
-          : market.leverageV2.hasLeverage()
-            ? ((await market.leverageV2.repay(stateCollateral, userCollateral, userBorrowed)) as Hex)
-            : ((await market.deleverage.repay(userCollateral)) as Hex),
-    }),
-    validationSuite: repayFromCollateralValidationSuite,
+    mutationFn: async (mutation, { market }) => {
+      const { stateCollateral, userBorrowed, userCollateral, isFull } = mutation
+
+      await waitForApproval({
+        isApproved: () =>
+          fetchRepayIsApproved({
+            chainId,
+            marketId,
+            userAddress,
+            stateCollateral,
+            userCollateral,
+            userBorrowed,
+            isFull,
+          }),
+        onApprove: () => approveRepay(market, mutation),
+        message: t`Approved repayment`,
+        config,
+      })
+
+      return { hash: await repay(market, mutation) }
+    },
+    validationSuite: repayFromCollateralIsFullValidationSuite,
     pendingMessage: (mutation, { market }) => t`Repaying loan... ${formatTokenAmounts(market, mutation)}`,
     successMessage: (mutation, { market }) => t`Loan repaid! ${formatTokenAmounts(market, mutation)}`,
     onSuccess: onRepaid,

apps/main/src/llamalend/queries/repay/repay-expected-borrowed.query.ts

@@ -7,10 +7,10 @@ import { repayFromCollateralValidationSuite } from '../validation/manage-loan.va
 
 type RepayExpectedBorrowedResult = {
   totalBorrowed: Decimal
-  borrowedFromStateCollateral: Decimal
-  borrowedFromUserCollateral: Decimal
-  userBorrowed: Decimal
-  avgPrice: Decimal
+  borrowedFromStateCollateral?: Decimal
+  borrowedFromUserCollateral?: Decimal
+  userBorrowed?: Decimal
+  avgPrice?: Decimal
 }
 
 export const { useQuery: useRepayExpectedBorrowed } = queryFactory({
@@ -30,20 +30,21 @@ export const { useQuery: useRepayExpectedBorrowed } = queryFactory({
       { userBorrowed },
     ] as const,
   queryFn: async ({ marketId, stateCollateral, userCollateral, userBorrowed }: RepayFromCollateralQuery) => {
+    // todo: investigate if this is OK when the user's position is not leveraged
     const market = getLlamaMarket(marketId)
-    return market instanceof LendMarketTemplate
-      ? ((await market.leverage.repayExpectedBorrowed(
-          stateCollateral,
-          userCollateral,
-          userBorrowed,
-        )) as RepayExpectedBorrowedResult)
-      : market.leverageV2.hasLeverage()
-        ? ((await market.leverageV2.repayExpectedBorrowed(
-            stateCollateral,
-            userCollateral,
-            userBorrowed,
-          )) as RepayExpectedBorrowedResult)
-        : null
+    if (market instanceof LendMarketTemplate) {
+      const result = await market.leverage.repayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)
+      return result as RepayExpectedBorrowedResult
+    }
+    if (market.leverageV2.hasLeverage()) {
+      const result = await market.leverageV2.repayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)
+      return result as RepayExpectedBorrowedResult
+    }
+
+    console.assert(!+stateCollateral, `Expected 0 stateCollateral for non-leverage market, got ${stateCollateral}`)
+    console.assert(!+userBorrowed, `Expected 0 userBorrowed for non-leverage market, got ${userBorrowed}`)
+    const { stablecoins, routeIdx } = await market.deleverage.repayStablecoins(userCollateral)
+    return { totalBorrowed: stablecoins[routeIdx] as Decimal }
   },
   staleTime: '1m',
   validationSuite: repayFromCollateralValidationSuite,

apps/main/src/llamalend/queries/repay/repay-gas-estimate.query.ts

@@ -5,10 +5,11 @@ import type { IChainId } from '@curvefi/llamalend-api/lib/interfaces'
 import { LendMarketTemplate } from '@curvefi/llamalend-api/lib/lendMarkets'
 import { type FieldsOf } from '@ui-kit/lib'
 import { queryFactory, rootKeys } from '@ui-kit/lib/model'
-import type { RepayFromCollateralQuery } from '../validation/manage-loan.types'
-import { repayFromCollateralValidationSuite } from '../validation/manage-loan.validation'
+import type { RepayFromCollateralHealthQuery } from '../validation/manage-loan.types'
+import { repayFromCollateralIsFullValidationSuite } from '../validation/manage-loan.validation'
+import { repayIsFullQueryKey } from './repay-is-full.query'
 
-type RepayFromCollateralGasQuery<T = IChainId> = RepayFromCollateralQuery<T>
+type RepayFromCollateralGasQuery<T = IChainId> = RepayFromCollateralHealthQuery<T>
 type RepayFromCollateralGasParams<T = IChainId> = FieldsOf<RepayFromCollateralGasQuery<T>>
 
 const { useQuery: useRepayGasEstimate } = queryFactory({
@@ -19,23 +20,47 @@ const { useQuery: useRepayGasEstimate } = queryFactory({
     userCollateral = '0',
     userBorrowed = '0',
     userAddress,
+    isFull,
   }: RepayFromCollateralGasParams) =>
     [
       ...rootKeys.userMarket({ chainId, marketId, userAddress }),
       'repay-from-collateral-gas-estimation',
       { stateCollateral },
       { userCollateral },
       { userBorrowed },
+      { isFull },
     ] as const,
-  queryFn: async ({ marketId, stateCollateral, userCollateral, userBorrowed }: RepayFromCollateralGasQuery) => {
+  queryFn: async ({
+    marketId,
+    stateCollateral,
+    userCollateral,
+    userBorrowed,
+    isFull,
+    userAddress,
+  }: RepayFromCollateralGasQuery) => {
     const market = getLlamaMarket(marketId)
-    return market instanceof LendMarketTemplate
-      ? await market.leverage.estimateGas.repay(stateCollateral, userCollateral, userBorrowed)
-      : market.leverageV2.hasLeverage()
-        ? await market.leverageV2.estimateGas.repay(stateCollateral, userCollateral, userBorrowed)
-        : await market.deleverage.estimateGas.repay(userCollateral)
+    if (isFull) {
+      return market instanceof LendMarketTemplate
+        ? await market.estimateGas.fullRepay(userAddress)
+        : await market.fullRepayEstimateGas(userAddress)
+    }
+    if (market instanceof LendMarketTemplate) {
+      return await market.leverage.estimateGas.repay(stateCollateral, userCollateral, userBorrowed)
+    }
+    if (market.leverageV2.hasLeverage()) {
+      return await market.leverageV2.estimateGas.repay(stateCollateral, userCollateral, userBorrowed)
+    }
+    return await market.deleverage.estimateGas.repay(userCollateral)
   },
-  validationSuite: repayFromCollateralValidationSuite,
+  validationSuite: repayFromCollateralIsFullValidationSuite,
+  dependencies: ({
+    chainId,
+    marketId,
+    stateCollateral = '0',
+    userCollateral = '0',
+    userBorrowed = '0',
+    userAddress,
+  }) => [repayIsFullQueryKey({ chainId, marketId, stateCollateral, userCollateral, userBorrowed, userAddress })],
 })
 
 export const useRepayEstimateGas = <ChainId extends IChainId>(