feat: repay debt with supply

Author: cesarenaldi

.changeset/shaggy-flowers-sip.md

@@ -0,0 +1,7 @@
+---
+"@aave/graphql": patch
+"@aave/client": patch
+"@aave/react": patch
+---
+
+**feat:** `repayWithSupplyQuote` action, `useRepayWithSupplyQuote` and `useRepayWithSupply` hooks.

packages/client/src/actions/swap.ts

@@ -7,6 +7,8 @@ import type {
   PrepareBorrowSwapResult,
   PreparePositionSwapRequest,
   PreparePositionSwapResult,
+  PrepareRepayWithSupplyRequest,
+  PrepareRepayWithSupplyResult,
   PrepareSupplySwapRequest,
   PrepareSupplySwapResult,
   PrepareSwapCancelRequest,
@@ -33,6 +35,7 @@ import {
   PreparePositionSwapQuery,
   PrepareSwapCancelQuery,
   PrepareTokenSwapQuery,
+  RepayWithSupplyQuoteQuery,
   SupplySwapQuoteQuery,
   SwapMutation,
   SwappableTokensQuery,
@@ -216,6 +219,38 @@ export function borrowSwapQuote(
   );
 }
 
+/**
+ * @experimental
+ * Fetches a repay with supply quote for repaying debt using collateral.
+ *
+ * ```ts
+ * const result = await repayWithSupplyQuote(client, {
+ *   market: {
+ *     sellPosition: userSupplyItemId('collateral_123'),
+ *     buyPosition: userBorrowItemId('debt_456'),
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc...'),
+ *   },
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The repay with supply request parameters.
+ * @param options - The query options.
+ * @returns The repay with supply result with quote, approvals, and preview.
+ */
+export function repayWithSupplyQuote(
+  client: AaveClient,
+  request: PrepareRepayWithSupplyRequest,
+  options: Required<CurrencyQueryOptions> = DEFAULT_QUERY_OPTIONS,
+): ResultAsync<PrepareRepayWithSupplyResult, UnexpectedError> {
+  return client.query(
+    RepayWithSupplyQuoteQuery,
+    { request, currency: options.currency },
+    { batch: false },
+  );
+}
+
 /**
  * @experimental
  * Prepares a position swap by obtaining the typed data for signing.

packages/graphql/src/fragments/swaps.ts

@@ -466,6 +466,22 @@ export const PrepareBorrowSwapResultFragment: FragmentDocumentFor<
   [PositionSwapByIntentApprovalsRequiredFragment],
 );
 
+export type PrepareRepayWithSupplyResult =
+  PositionSwapByIntentApprovalsRequired;
+
+export const PrepareRepayWithSupplyResultFragment: FragmentDocumentFor<
+  PrepareRepayWithSupplyResult,
+  'PrepareRepayWithSupplyResult'
+> = graphql(
+  `fragment PrepareRepayWithSupplyResult on PrepareRepayWithSupplyResult {
+    __typename
+    ... on PositionSwapByIntentApprovalsRequired {
+      ...PositionSwapByIntentApprovalsRequired
+    }
+  }`,
+  [PositionSwapByIntentApprovalsRequiredFragment],
+);
+
 export type PreparePositionSwapResult = SwapByIntent;
 
 export const PreparePositionSwapResultFragment: FragmentDocumentFor<

packages/graphql/src/swaps.ts

@@ -3,6 +3,7 @@ import {
   PaginatedUserSwapsResultFragment,
   PrepareBorrowSwapResultFragment,
   PreparePositionSwapResultFragment,
+  PrepareRepayWithSupplyResultFragment,
   PrepareSupplySwapResultFragment,
   PrepareSwapCancelResultFragment,
   PrepareTokenSwapResultFragment,
@@ -143,6 +144,21 @@ export const BorrowSwapQuoteQuery = graphql(
 );
 export type PrepareBorrowSwapRequest = RequestOf<typeof BorrowSwapQuoteQuery>;
 
+/**
+ * @internal
+ */
+export const RepayWithSupplyQuoteQuery = graphql(
+  `query RepayWithSupplyQuote($request: PrepareRepayWithSupplyRequest!, $currency: Currency!) {
+    value: repayWithSupplyQuote(request: $request) {
+      ...PrepareRepayWithSupplyResult
+    }
+  }`,
+  [PrepareRepayWithSupplyResultFragment],
+);
+export type PrepareRepayWithSupplyRequest = RequestOf<
+  typeof RepayWithSupplyQuoteQuery
+>;
+
 /**
  * @internal
  */

packages/react/src/swap.test.ts

@@ -9,7 +9,9 @@ import {
   BorrowSwapQuoteQuery,
   type PrepareBorrowSwapRequest,
   PreparePositionSwapQuery,
+  type PrepareRepayWithSupplyRequest,
   type PrepareSupplySwapRequest,
+  RepayWithSupplyQuoteQuery,
   SupplySwapQuoteQuery,
   SwapMutation,
 } from '@aave/graphql';
@@ -32,7 +34,7 @@ import {
   describe,
   it,
 } from 'vitest';
-import { useBorrowSwap, useSupplySwap } from './swap';
+import { useBorrowSwap, useRepayWithSupply, useSupplySwap } from './swap';
 import { renderHookWithinContext } from './test-utils';
 import { useSendTransaction } from './viem';
 
@@ -229,4 +231,76 @@ describe('Given the swap hooks', () => {
       assertOk(result);
     });
   });
+
+  describe(`When using the '${useRepayWithSupply.name}' hook`, () => {
+    beforeEach(() => {
+      server.use(
+        api.query(RepayWithSupplyQuoteQuery, () =>
+          msw.HttpResponse.json({
+            data: {
+              value: {
+                __typename: 'PositionSwapByIntentApprovalsRequired',
+                quote: makeSwapQuote(),
+                approvals: [
+                  makePositionSwapPositionManagerApproval({
+                    byTransaction: dummyTransactionRequest,
+                  }),
+                  makePositionSwapAdapterContractApproval({
+                    byTransaction: dummyTransactionRequest,
+                  }),
+                ],
+              },
+            },
+          }),
+        ),
+      );
+    });
+
+    it('Then it should support position swap with position manager and adapter contract approvals via signatures', async () => {
+      const {
+        result: {
+          current: [swap],
+        },
+      } = renderHookWithinContext(() =>
+        useRepayWithSupply((plan) => {
+          switch (plan.__typename) {
+            case 'PositionSwapPositionManagerApproval':
+            case 'PositionSwapAdapterContractApproval':
+              return signSwapTypedDataWith(walletClient, plan.bySignature);
+
+            case 'SwapByIntent':
+              return signSwapTypedDataWith(walletClient, plan.data);
+          }
+        }),
+      );
+
+      const result = await swap({} as PrepareRepayWithSupplyRequest);
+
+      assertOk(result);
+    });
+
+    it('Then it should support position swap with position manager and adapter contract approvals via transactions', async () => {
+      const {
+        result: {
+          current: [swap],
+        },
+      } = renderHookWithinContext(() => {
+        const [sendTransaction] = useSendTransaction(walletClient);
+        return useRepayWithSupply((plan) => {
+          switch (plan.__typename) {
+            case 'PositionSwapPositionManagerApproval':
+            case 'PositionSwapAdapterContractApproval':
+              return sendTransaction(plan.byTransaction);
+
+            case 'SwapByIntent':
+              return signSwapTypedDataWith(walletClient, plan.data);
+          }
+        });
+      });
+
+      const result = await swap({} as PrepareRepayWithSupplyRequest);
+
+      assertOk(result);
+    });
+  });
 });