feat: new guard for borrowing power on debt swap

Author: mgrabina

src/components/transactions/Swap/errors/SwapErrors.tsx

@@ -16,6 +16,7 @@ import {
   hasInsufficientBalance,
   InsufficientBalanceGuard,
 } from './shared/InsufficientBalanceGuard';
+import { InsufficientBorrowPowerBlockingGuard } from './shared/InsufficientBorrowPowerBlockingGuard';
 import {
   hasInsufficientLiquidity,
   InsufficientLiquidityBlockingGuard,
@@ -124,6 +125,16 @@ export const SwapErrors = ({
     );
   }
 
+  if (isProtocolSwapState(state) && state.swapType === SwapType.DebtSwap) {
+    return (
+      <InsufficientBorrowPowerBlockingGuard
+        state={state}
+        setState={setState}
+        isSwapFlowSelected={state.isSwapFlowSelected}
+      />
+    );
+  }
+
   if (!state.error) {
     return null;
   }

src/components/transactions/Swap/errors/shared/InsufficientBorrowPowerBlockingError.tsx

@@ -0,0 +1,16 @@
+import { Trans } from '@lingui/macro';
+import { SxProps, Typography } from '@mui/material';
+import { Warning } from 'src/components/primitives/Warning';
+
+export const InsufficientBorrowPowerBlockingError = ({ sx }: { sx?: SxProps }) => {
+  return (
+    <Warning severity="error" sx={{ mt: 4, ...sx }} icon={false}>
+      <Typography variant="caption">
+        <Trans>
+          Insufficient collateral to cover new borrow position. Wallet must have borrowing power
+          remaining to perform debt switch.
+        </Trans>
+      </Typography>
+    </Warning>
+  );
+};

src/components/transactions/Swap/errors/shared/InsufficientBorrowPowerBlockingGuard.tsx

@@ -0,0 +1,97 @@
+import { SxProps } from '@mui/material';
+import { Dispatch, useEffect } from 'react';
+import { useAppDataContext } from 'src/hooks/app-data-provider/useAppDataProvider';
+
+import {
+  ActionsBlockedReason,
+  ProtocolSwapState,
+  SwapError,
+  SwapState,
+  SwapType,
+} from '../../types';
+import { InsufficientBorrowPowerBlockingError } from './InsufficientBorrowPowerBlockingError';
+
+export const hasInsufficientBorrowPower = (state: SwapState, availableBorrowsUSD?: string) => {
+  if (state.swapType !== SwapType.DebtSwap) return false;
+
+  const buyAmount = state.buyAmountFormatted;
+  const sellAmount = state.sellAmountFormatted;
+  const sourceReserve = state.sourceReserve?.reserve;
+  const destinationReserve = state.destinationReserve?.reserve;
+  if (!buyAmount || !sellAmount || !sourceReserve || !destinationReserve) return false;
+
+  const repayUsd = Number(buyAmount) * Number(sourceReserve.priceInUSD);
+  const newDebtUsd = Number(sellAmount) * Number(destinationReserve.priceInUSD);
+  const priceImpactDifference = newDebtUsd - repayUsd;
+
+  const available = Number(availableBorrowsUSD || '0');
+
+  return available === 0 || priceImpactDifference > available;
+};
+
+export const InsufficientBorrowPowerBlockingGuard = ({
+  state,
+  setState,
+  sx,
+  isSwapFlowSelected,
+}: {
+  state: ProtocolSwapState;
+  setState: Dispatch<Partial<SwapState>>;
+  sx?: SxProps;
+  isSwapFlowSelected: boolean;
+}) => {
+  const { user: extendedUser } = useAppDataContext();
+
+  useEffect(() => {
+    const isBlocking = hasInsufficientBorrowPower(state, extendedUser?.availableBorrowsUSD);
+
+    if (isBlocking) {
+      const isAlreadyBlockingError =
+        state.error?.rawError instanceof Error &&
+        state.error.rawError.message === 'InsufficientBorrowPowerError';
+
+      if (!isAlreadyBlockingError) {
+        const blockingError: SwapError = {
+          rawError: new Error('InsufficientBorrowPowerError'),
+          message:
+            'Insufficient collateral to cover new borrow position. Wallet must have borrowing power remaining to perform debt switch.',
+          actionBlocked: true,
+        };
+        setState({
+          error: blockingError,
+          actionsBlocked: {
+            [ActionsBlockedReason.INSUFFICIENT_BORROW_POWER]: true,
+          },
+        });
+      }
+    } else {
+      const isBlockingError =
+        state.error?.rawError instanceof Error &&
+        state.error.rawError.message === 'InsufficientBorrowPowerError';
+      const isBorrowPowerBlocked =
+        state.actionsBlocked?.[ActionsBlockedReason.INSUFFICIENT_BORROW_POWER];
+      if (isBlockingError || isBorrowPowerBlocked) {
+        setState({
+          ...(isBlockingError ? { error: undefined } : {}),
+          actionsBlocked: {
+            [ActionsBlockedReason.INSUFFICIENT_BORROW_POWER]: undefined,
+          },
+        });
+      }
+    }
+  }, [
+    state.sellAmountFormatted,
+    state.buyAmountFormatted,
+    state.destinationReserve?.reserve?.priceInUSD,
+    state.sourceReserve?.reserve?.priceInUSD,
+    extendedUser?.availableBorrowsUSD,
+    state.error,
+    state.actionsBlocked,
+  ]);
+
+  if (hasInsufficientBorrowPower(state, extendedUser?.availableBorrowsUSD)) {
+    return <InsufficientBorrowPowerBlockingError sx={{ mb: !isSwapFlowSelected ? 0 : 4, ...sx }} />;
+  }
+
+  return null;
+};

src/components/transactions/Swap/types/state.types.ts

@@ -25,6 +25,7 @@ export enum ActionsBlockedReason {
   INSUFFICIENT_LIQUIDITY = 'INSUFFICIENT_LIQUIDITY',
   FLASH_LOAN_DISABLED = 'FLASH_LOAN_DISABLED',
   IS_LIQUIDATABLE = 'IS_LIQUIDATABLE',
+  INSUFFICIENT_BORROW_POWER = 'INSUFFICIENT_BORROW_POWER',
 }
 
 /**

src/locales/el/messages.js

@@ -3765,6 +3765,10 @@ msgstr "This asset is eligible for Kernel points incentive program. Aave Labs do
 msgid "You have no rewards to claim at this time."
 msgstr "You have no rewards to claim at this time."
 
+#: src/components/transactions/Swap/errors/shared/InsufficientBorrowPowerBlockingError.tsx
+msgid "Insufficient collateral to cover new borrow position. Wallet must have borrowing power remaining to perform debt switch."
+msgstr "Insufficient collateral to cover new borrow position. Wallet must have borrowing power remaining to perform debt switch."
+
 #: src/components/transactions/StakeRewardClaimRestake/StakeRewardClaimRestakeModalContent.tsx
 msgid "Restaked"
 msgstr "Restaked"