Merge branch 'main' into juan/swap-sign-action-hook

Author: juangm

examples/supply/src/SupplyForm.tsx

@@ -1,10 +1,10 @@
-import { useSendTransaction } from '@aave/react/viem';
 import {
   bigDecimal,
   evmAddress,
   type Reserve,
   useSupply,
 } from '@aave/react-next';
+import { useSendTransaction } from '@aave/react-next/viem';
 import { useState } from 'react';
 import type { WalletClient } from 'viem';
 

packages/client/src/actions/swap.ts

@@ -48,6 +48,7 @@ import { type CurrencyQueryOptions, DEFAULT_QUERY_OPTIONS } from '../options';
  *   sell: { erc20: evmAddress('0x6B175474E...') },
  *   amount: bigDecimal('1000'),
  *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
  * });
  * ```
  *

packages/client/src/actions/transactions.ts

@@ -71,18 +71,20 @@ export function borrow(
  *
  * ```ts
  * const result = await supply(client, {
+ *   reserve: {
+ *     reserveId: "1234567890",
+ *     spoke: evmAddress('0x8787…'),
+ *     chainId: chainId(1),
+ *   },
  *   amount: {
  *     erc20: {
  *       value: bigDecimal('1000'),
  *     },
  *   },
+ *   enableCollateral: true, // Optional, defaults to true
  *   sender: evmAddress('0x9abc…'),
- *   reserve: {
- *     spoke: evmAddress('0x87870bca…'),
- *     reserveId: reserveId(1),
- *     chainId: chainId(1),
- *   },
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
+ *   // onBehalfOf: evmAddress('0xdef0…'), // Optional, if supplying on behalf of another user
+ * });
  *
  * if (result.isErr()) {
  *   // Handle error, e.g. insufficient balance, signing error, etc.

packages/client/src/test-utils.ts

@@ -137,10 +137,12 @@ export function fundNativeAddress(
 }
 
 export function fundErc20Address(
-  tokenAddress: EvmAddress,
   address: EvmAddress,
-  amount: BigDecimal,
-  decimals = 18,
+  token: {
+    address: EvmAddress;
+    amount: BigDecimal;
+    decimals?: number;
+  },
 ): ResultAsync<string, UnexpectedError> {
   const publicClient = createPublicClient({
     chain: {
@@ -156,14 +158,14 @@ export function fundErc20Address(
   });
 
   // Convert amount to the smallest unit (e.g., wei for 18 decimals)
-  const amountInSmallestUnit = parseUnits(amount, decimals);
+  const amountInSmallestUnit = parseUnits(token.amount, token.decimals ?? 18);
   const amountHex = `0x${amountInSmallestUnit.toString(16)}`;
 
   return ResultAsync.fromPromise(
     publicClient
       .request<TSetErc20BalanceRpc>({
         method: 'tenderly_setErc20Balance',
-        params: [tokenAddress, address, amountHex],
+        params: [token.address, address, amountHex],
       })
       .then(async (res) => {
         await wait(500); // Temporal fix to avoid tenderly issues with the balance not being set

packages/spec/borrow/business.spec.ts

@@ -0,0 +1,84 @@
+import { assertOk, bigDecimal, evmAddress } from '@aave/client-next';
+import { borrow, userBorrows } from '@aave/client-next/actions';
+import {
+  client,
+  createNewWallet,
+  ETHEREUM_USDC_ADDRESS,
+  fundErc20Address,
+} from '@aave/client-next/test-utils';
+import { sendWith } from '@aave/client-next/viem';
+import type { Reserve } from '@aave/graphql-next';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { assertSingleElementArray } from '../test-utils';
+import { supplyToRandomERC20Reserve } from './helper';
+
+describe('Aave V4 Borrow Scenarios', () => {
+  describe('Given a user with a supply position as collateral', () => {
+    describe('When the user borrows an ERC20 asset', () => {
+      const user = createNewWallet();
+      let reserve: Reserve;
+
+      beforeAll(async () => {
+        const setup = await fundErc20Address(
+          evmAddress(user.account!.address),
+          {
+            address: ETHEREUM_USDC_ADDRESS,
+            amount: bigDecimal('100'),
+            decimals: 6,
+          },
+        ).andThen(() =>
+          supplyToRandomERC20Reserve(client, user, ETHEREUM_USDC_ADDRESS),
+        );
+
+        assertOk(setup);
+        reserve = setup.value;
+      });
+
+      it(`Then the user's borrow positions are updated`, async () => {
+        const amountToBorrow = bigDecimal('50');
+
+        const result = await borrow(client, {
+          sender: evmAddress(user.account!.address),
+          reserve: {
+            spoke: reserve.spoke.address,
+            reserveId: reserve.id,
+            chainId: reserve.chain.chainId,
+          },
+          amount: {
+            erc20: {
+              value: amountToBorrow,
+            },
+          },
+        })
+          .andThen(sendWith(user))
+          .andThen(client.waitForTransaction)
+          .andThen(() =>
+            userBorrows(client, {
+              query: {
+                userSpoke: {
+                  spoke: {
+                    address: reserve.spoke.address,
+                    chainId: reserve.chain.chainId,
+                  },
+                  user: evmAddress(user.account!.address),
+                },
+              },
+            }),
+          );
+
+        assertOk(result);
+        assertSingleElementArray(result.value);
+        // BUG: The amount is slightly different from the total borrow amount
+        expect(result.value[0].amount.value.formatted).toBeBigDecimalCloseTo(
+          amountToBorrow,
+          4,
+        );
+        expect(result.value[0].amount.isWrappedNative).toBe(false);
+      });
+    });
+
+    describe('When the user borrows from a reserve that supports native borrowing', () => {
+      it.todo(`Then the user's borrow positions are updated`);
+    });
+  });
+});

packages/spec/borrow/helper.ts

@@ -0,0 +1,77 @@
+import type { AaveClient, Reserve, SupplyRequest } from '@aave/client-next';
+import {
+  bigDecimal,
+  chainId,
+  type EvmAddress,
+  evmAddress,
+  invariant,
+  ReservesRequestFilter,
+  type ResultAsync,
+  type TxHash,
+} from '@aave/client-next';
+import { reserves, supply } from '@aave/client-next/actions';
+import { sendWith } from '@aave/client-next/viem';
+import type { WalletClient } from 'viem';
+
+export function supplyToReserve(
+  client: AaveClient,
+  request: SupplyRequest,
+  user: WalletClient,
+): ResultAsync<TxHash, Error> {
+  return supply(client, request)
+    .andThen(sendWith(user))
+    .andThen(client.waitForTransaction);
+}
+
+export function findReserveToSupply(
+  client: AaveClient,
+  token: EvmAddress,
+): ResultAsync<Reserve, Error> {
+  return reserves(client, {
+    query: {
+      tokens: [
+        {
+          chainId: chainId(1),
+          address: token,
+        },
+      ],
+    },
+    filter: ReservesRequestFilter.Supply,
+  }).map((listReserves) => {
+    invariant(
+      listReserves.length > 0,
+      `No reserves found for the token ${token}`,
+    );
+    const reserveToSupply = listReserves.find(
+      (reserve) => reserve.canSupply === true,
+    );
+    invariant(
+      reserveToSupply,
+      `No reserve found to supply to for the token ${token}`,
+    );
+    return reserveToSupply;
+  });
+}
+
+export function supplyToRandomERC20Reserve(
+  client: AaveClient,
+  user: WalletClient,
+  token: EvmAddress,
+  amount = bigDecimal('100'),
+): ResultAsync<Reserve, Error> {
+  return findReserveToSupply(client, token).andThen((reserve) =>
+    supplyToReserve(
+      client,
+      {
+        reserve: {
+          reserveId: reserve.id,
+          chainId: reserve.chain.chainId,
+          spoke: reserve.spoke.address,
+        },
+        amount: { erc20: { value: amount } },
+        sender: evmAddress(user.account!.address),
+      },
+      user,
+    ).map(() => reserve),
+  );
+}