feat: add Repay with collateral UI

Author: therealemjy

.changeset/quiet-dots-call.md

@@ -0,0 +1,5 @@
+---
+"@venusprotocol/evm": minor
+---
+
+add Repay with collateral UI

apps/evm/src/__mocks__/models/swap.ts

@@ -0,0 +1,13 @@
+import type { ExactInSwapQuote } from 'types';
+import { lisUsd, usdc } from './tokens';
+
+export const exactInSwapQuote: ExactInSwapQuote = {
+  fromToken: usdc,
+  toToken: lisUsd,
+  direction: 'exact-in',
+  priceImpactPercentage: 0.1,
+  fromTokenAmountSoldMantissa: 100000000n,
+  expectedToTokenAmountReceivedMantissa: 100000000n,
+  minimumToTokenAmountReceivedMantissa: 100000000n,
+  callData: '0x',
+};

apps/evm/src/clients/api/__mocks__/index.ts

@@ -695,6 +695,14 @@ export const useOpenLeveragedPosition = vi.fn(
     }),
 );
 
+export const useRepayWithCollateral = vi.fn(
+  (_variables: never, options?: MutationObserverOptions) =>
+    useMutation({
+      mutationFn: vi.fn(),
+      ...options,
+    }),
+);
+
 export const withdrawXvs = vi.fn();
 export const useWithdrawXvs = (options?: MutationObserverOptions) =>
   useMutation({

apps/evm/src/clients/api/index.ts

@@ -32,6 +32,7 @@ export * from './mutations/useWithdraw';
 export * from './mutations/useImportSupplyPosition';
 export * from './mutations/useSetEModeGroup';
 export * from './mutations/useOpenLeveragedPosition';
+export * from './mutations/useRepayWithCollateral';
 
 // Queries
 export * from './queries/getVaiTreasuryPercentage';

apps/evm/src/clients/api/mutations/useImportSupplyPosition/__tests__/__snapshots__/index.spec.ts.snap

@@ -87,7 +87,7 @@ exports[`useImportSupplyPosition > returns a Fusion quote on success 6`] = `
       "sponsorship": true,
       "trigger": {
         "amount": 20000000000000000000n,
-        "approvalAmount": 24024000000000000000n,
+        "approvalAmount": 24000002400000000000n,
         "chainId": 97,
         "gasLimit": 500000n,
         "tokenAddress": "0xfakeAXVSAddress",

apps/evm/src/clients/api/mutations/useOpenLeveragedPosition/__tests__/index.spec.ts

@@ -1,24 +1,12 @@
-import { lisUsd, usdc } from '__mocks__/models/tokens';
+import { exactInSwapQuote as fakeSwapQuote } from '__mocks__/models/swap';
 import { vLisUSD, vUsdc } from '__mocks__/models/vTokens';
 import { queryClient } from 'clients/api';
 import { useGetContractAddress } from 'hooks/useGetContractAddress';
 import { useSendTransaction } from 'hooks/useSendTransaction';
 import { renderHook } from 'testUtils/render';
-import type { ExactInSwapQuote } from 'types';
 import type { Mock } from 'vitest';
 import { useOpenLeveragedPosition } from '..';
 
-const fakeSwapQuote: ExactInSwapQuote = {
-  fromToken: usdc,
-  toToken: lisUsd,
-  direction: 'exact-in',
-  priceImpactPercentage: 0.1,
-  fromTokenAmountSoldMantissa: 100000000n,
-  expectedToTokenAmountReceivedMantissa: 100000000n,
-  minimumToTokenAmountReceivedMantissa: 100000000n,
-  callData: '0x',
-};
-
 vi.mock('libs/contracts');
 
 describe('useOpenLeveragedPosition', () => {

apps/evm/src/clients/api/mutations/useRepay/__tests__/index.spec.ts

@@ -92,8 +92,7 @@ describe('useRepay', () => {
     expect(await fn(repayFullLoanInput)).toMatchInlineSnapshot(
       {
         abi: expect.any(Array),
-      },
-      `
+      }, `
       {
         "abi": Any<Array>,
         "address": "0xfakeMaximillionContractAddress",
@@ -102,10 +101,9 @@ describe('useRepay', () => {
           "0x2E7222e51c0f6e98610A1543Aa3836E092CDe62c",
         ],
         "functionName": "repayBehalfExplicit",
-        "value": 10010000000000000n,
+        "value": 10000001000000000n,
       }
-    `,
-    );
+    `);
 
     onConfirmed({ input: fakeInput });
 

apps/evm/src/clients/api/mutations/useRepayWithCollateral/__tests__/__snapshots__/index.spec.ts.snap

@@ -0,0 +1,53 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`useRepayWithCollateral > calls useSendTransaction with correct parameters 'with single asset' 1`] = `
+{
+  "abi": Any<Object>,
+  "address": "0xfakeLeverageManagerContractAddress",
+  "args": [
+    "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+    100000000n,
+  ],
+  "functionName": "exitSingleAssetLeverage",
+}
+`;
+
+exports[`useRepayWithCollateral > calls useSendTransaction with correct parameters 'with single asset' 2`] = `
+[
+  [
+    {
+      "queryKey": [
+        "GET_POOLS",
+      ],
+    },
+  ],
+]
+`;
+
+exports[`useRepayWithCollateral > calls useSendTransaction with correct parameters 'with swapQuote' 1`] = `
+{
+  "abi": Any<Object>,
+  "address": "0xfakeLeverageManagerContractAddress",
+  "args": [
+    "0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7",
+    100000000n,
+    "0x170d3b2da05cc2124334240fB34ad1359e34C562",
+    100000000n,
+    100000000n,
+    "0x",
+  ],
+  "functionName": "exitLeverage",
+}
+`;
+
+exports[`useRepayWithCollateral > calls useSendTransaction with correct parameters 'with swapQuote' 2`] = `
+[
+  [
+    {
+      "queryKey": [
+        "GET_POOLS",
+      ],
+    },
+  ],
+]
+`;

apps/evm/src/clients/api/mutations/useRepayWithCollateral/__tests__/index.spec.ts

@@ -0,0 +1,62 @@
+import fakeAccountAddress from '__mocks__/models/address';
+import { exactInSwapQuote as fakeSwapQuote } from '__mocks__/models/swap';
+import { vLisUSD, vUsdc } from '__mocks__/models/vTokens';
+import { queryClient } from 'clients/api';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import { useSendTransaction } from 'hooks/useSendTransaction';
+import { renderHook } from 'testUtils/render';
+import type { Mock } from 'vitest';
+import { useRepayWithCollateral } from '..';
+
+vi.mock('libs/contracts');
+
+describe('useRepayWithCollateral', () => {
+  it('should throw error if LeverageManager contract address is not available', async () => {
+    (useGetContractAddress as Mock).mockReturnValue({ address: undefined });
+
+    renderHook(() => useRepayWithCollateral());
+
+    const { fn } = (useSendTransaction as Mock).mock.calls[0][0];
+
+    expect(async () => fn()).rejects.toThrow('somethingWentWrong');
+  });
+
+  it.each([
+    {
+      label: 'with swapQuote',
+      input: {
+        collateralVToken: vUsdc,
+        repaidVToken: vLisUSD,
+        swapQuote: fakeSwapQuote,
+      },
+    },
+    {
+      label: 'with single asset',
+      input: {
+        vToken: vUsdc,
+        amountMantissa: 100000000n,
+      },
+    },
+  ])('calls useSendTransaction with correct parameters $label', async ({ input }) => {
+    renderHook(() => useRepayWithCollateral(), {
+      accountAddress: fakeAccountAddress,
+    });
+
+    expect(useSendTransaction).toHaveBeenCalledWith({
+      fn: expect.any(Function),
+      onConfirmed: expect.any(Function),
+      options: undefined,
+    });
+
+    const { fn } = (useSendTransaction as Mock).mock.calls[0][0];
+
+    expect(await fn(input)).toMatchSnapshot({
+      abi: expect.any(Object),
+    });
+
+    const { onConfirmed } = (useSendTransaction as Mock).mock.calls[0][0];
+    await onConfirmed();
+
+    expect((queryClient.invalidateQueries as Mock).mock.calls).toMatchSnapshot();
+  });
+});

apps/evm/src/clients/api/mutations/useRepayWithCollateral/index.ts

@@ -0,0 +1,97 @@
+import type { Account, Address, Chain, Hex, WriteContractParameters } from 'viem';
+
+import { queryClient } from 'clients/api';
+import FunctionKey from 'constants/functionKey';
+import { useGetContractAddress } from 'hooks/useGetContractAddress';
+import { type UseSendTransactionOptions, useSendTransaction } from 'hooks/useSendTransaction';
+import { leverageManagerAbi } from 'libs/contracts';
+import { VError } from 'libs/errors';
+import type { SwapQuote, VToken } from 'types';
+
+type RepayWithCollateralWithSwapInput = {
+  swapQuote: SwapQuote;
+  collateralVToken: VToken;
+  repaidVToken: VToken;
+};
+
+type RepayWithCollateralWithSingleAssetInput = {
+  vToken: VToken;
+  amountMantissa: bigint;
+};
+
+type RepayWithCollateralInput =
+  | RepayWithCollateralWithSwapInput
+  | RepayWithCollateralWithSingleAssetInput;
+
+type Options = UseSendTransactionOptions<RepayWithCollateralInput>;
+
+export const useRepayWithCollateral = (options?: Partial<Options>) => {
+  const { address: leverageManagerContractAddress } = useGetContractAddress({
+    name: 'LeverageManager',
+  });
+
+  return useSendTransaction({
+    fn: (input: RepayWithCollateralInput) => {
+      if (!leverageManagerContractAddress) {
+        throw new VError({ type: 'unexpected', code: 'somethingWentWrong' });
+      }
+
+      if ('swapQuote' in input) {
+        const collateralAmountMantissa =
+          input.swapQuote.direction === 'exact-in' ||
+          input.swapQuote.direction === 'approximate-out'
+            ? input.swapQuote.fromTokenAmountSoldMantissa
+            : input.swapQuote.maximumFromTokenAmountSoldMantissa;
+
+        const repaidAmountMantissa =
+          input.swapQuote.direction === 'exact-in' ||
+          input.swapQuote.direction === 'approximate-out'
+            ? input.swapQuote.minimumToTokenAmountReceivedMantissa
+            : input.swapQuote.toTokenAmountReceivedMantissa;
+
+        return {
+          abi: leverageManagerAbi,
+          address: leverageManagerContractAddress,
+          functionName: 'exitLeverage',
+          args: [
+            input.collateralVToken.address,
+            collateralAmountMantissa,
+            input.repaidVToken.address,
+            repaidAmountMantissa, // borrowedAmountToFlashLoan
+            repaidAmountMantissa, // minAmountOutAfterSwap: this needs to correspond to
+            // borrowedAmountToFlashLoan + swap fee (which is currently 0%, hence why it is
+            // currently equal to borrowedAmountToFlashLoan)
+            input.swapQuote.callData,
+          ],
+        } as WriteContractParameters<
+          typeof leverageManagerAbi,
+          'exitLeverage',
+          readonly [Address, bigint, Address, bigint, bigint, Hex],
+          Chain,
+          Account
+        >;
+      }
+
+      return {
+        abi: leverageManagerAbi,
+        address: leverageManagerContractAddress,
+        functionName: 'exitSingleAssetLeverage',
+        args: [input.vToken.address, input.amountMantissa],
+      } as WriteContractParameters<
+        typeof leverageManagerAbi,
+        'exitSingleAssetLeverage',
+        readonly [Address, bigint],
+        Chain,
+        Account
+      >;
+    },
+    onConfirmed: () => {
+      // TODO: send analytic event
+
+      queryClient.invalidateQueries({
+        queryKey: [FunctionKey.GET_POOLS],
+      });
+    },
+    options,
+  });
+};