test: borrow

package.json

@@ -22,6 +22,8 @@
     "test:client": "vitest --project client",
     "test:client:local": "ENVIRONMENT=local vitest --project client",
     "test:react": "vitest --project react",
+    "test:withdraw": "vitest --project client packages/client/src/actions/withdraw.test.ts",
+    "test:borrow": "vitest --project client packages/client/src/actions/borrow.test.ts",
     "test": "vitest"
   },
   "license": "MIT",

packages/client/src/actions/__snapshots__/markets.test.ts.snap

@@ -93,9 +93,9 @@ exports[`Given the Aave Protocol v3 > When fetching user market state > Then it
   "__typename": "MarketUserState",
   "availableBorrowsBase": Any<String>,
   "currentLiquidationThreshold": Any<String>,
-  "eModeEnabled": Any<Boolean>,
+  "eModeEnabled": false,
   "healthFactor": Any<String>,
-  "isInIsolationMode": Any<Boolean>,
+  "isInIsolationMode": false,
   "ltv": Any<String>,
   "netAPY": Any<String>,
   "netWorth": Any<String>,

packages/client/src/actions/borrow.test.ts

@@ -0,0 +1,151 @@
+import type {
+  Market,
+  MarketUserReserveSupplyPosition,
+  SupplyRequest,
+} from '@aave/graphql';
+import { assertOk, bigDecimal, evmAddress } from '@aave/types';
+import type { WalletClient } from 'viem';
+import { beforeAll, describe, expect, it } from 'vitest';
+import {
+  client,
+  createNewWallet,
+  DEFAULT_MARKET_ADDRESS,
+  ETHEREUM_FORK_ID,
+  fundErc20Address,
+  WETH_ADDRESS,
+} from '../test-utils';
+import { sendWith } from '../viem';
+import { market } from './markets';
+import { borrow, collateralToggle, supply } from './transactions';
+import { userBorrows, userSupplies } from './user';
+
+async function supplyAndCheck(
+  wallet: WalletClient,
+  request: SupplyRequest,
+): Promise<MarketUserReserveSupplyPosition[]> {
+  const userAddress = evmAddress(wallet.account!.address);
+  const result = await supply(client, request)
+    .andThen(sendWith(wallet))
+    .andThen(() =>
+      userSupplies(client, {
+        markets: [{ address: request.market, chainId: request.chainId }],
+        user: userAddress,
+      }),
+    );
+  assertOk(result);
+  expect(result.value).toEqual([
+    expect.objectContaining({
+      balance: expect.objectContaining({
+        amount: expect.objectContaining({
+          value: expect.toBeBigDecimalCloseTo(
+            'erc20' in request.amount
+              ? request.amount.erc20.value
+              : request.amount.native,
+          ),
+        }),
+      }),
+      // Check if the position can be used as collateral
+      canBeCollateral: true,
+    }),
+  ]);
+  return result.value!;
+}
+
+describe('Given an Aave Market', () => {
+  let marketInfo: Market;
+  let initialPosition: MarketUserReserveSupplyPosition | undefined;
+
+  const wallet: WalletClient = createNewWallet();
+
+  beforeAll(async () => {
+    // Set up market info first
+    const result = await market(client, {
+      address: DEFAULT_MARKET_ADDRESS,
+      chainId: ETHEREUM_FORK_ID,
+    });
+    assertOk(result);
+    marketInfo = result.value!;
+
+    // Set up wallet and supply position
+    await fundErc20Address(
+      WETH_ADDRESS,
+      evmAddress(wallet.account!.address),
+      bigDecimal('0.011'),
+    );
+    const supplyResult = await supplyAndCheck(wallet, {
+      market: marketInfo.address,
+      chainId: marketInfo.chain.chainId,
+      supplier: evmAddress(wallet.account!.address),
+      amount: {
+        erc20: {
+          currency: WETH_ADDRESS,
+          value: '0.01',
+        },
+      },
+    });
+    initialPosition = supplyResult[0];
+  });
+
+  describe('And a user with a supply position', () => {
+    describe('When user set the supply as collateral', async () => {
+      it('Then it should be possible to borrow from the reserve', async () => {
+        // Enable collateral
+        const result = await collateralToggle(client, {
+          market: initialPosition!.market.address,
+          underlyingToken: initialPosition!.currency.address,
+          chainId: initialPosition!.market.chain.chainId,
+          user: evmAddress(wallet.account!.address),
+        })
+          .andThen(sendWith(wallet))
+          .andTee((tx) => console.log(`tx to enable collateral: ${tx}`))
+          .andThen(() => {
+            return userSupplies(client, {
+              markets: [
+                {
+                  address: initialPosition!.market.address,
+                  chainId: initialPosition!.market.chain.chainId,
+                },
+              ],
+              user: evmAddress(wallet.account!.address),
+            });
+          });
+        assertOk(result);
+        expect(result.value).toEqual([
+          expect.objectContaining({
+            isCollateral: true,
+          }),
+        ]);
+
+        // Borrow from the reserve
+        const borrowReserve = marketInfo.borrowReserves.find(
+          (reserve) => reserve.underlyingToken.symbol === 'USDC',
+        )!;
+        const borrowResult = await borrow(client, {
+          market: marketInfo.address,
+          chainId: marketInfo.chain.chainId,
+          borrower: evmAddress(wallet.account!.address),
+          amount: {
+            erc20: {
+              currency: borrowReserve.underlyingToken.address,
+              value: '10',
+            },
+          },
+        })
+          .andThen(sendWith(wallet))
+          .andTee((tx) => console.log(`tx to borrow: ${tx}`))
+          .andThen(() =>
+            userBorrows(client, {
+              markets: [
+                {
+                  address: marketInfo.address,
+                  chainId: marketInfo.chain.chainId,
+                },
+              ],
+              user: evmAddress(wallet.account!.address),
+            }),
+          );
+        assertOk(borrowResult);
+      });
+    });
+  });
+});

packages/client/src/actions/eMode.todo.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+
+// THIS IS A VERY WIP
+
+describe('Given an Aave Market', () => {
+  describe('And a user with a supply position', () => {
+    describe('When the user enables e-mode for that market', () => {
+      it('Then it should be possible to borrow from the reserve', () => {
+        expect(true).toBe(true);
+      });
+    });
+  });
+});

packages/client/src/actions/markets.test.ts

@@ -60,9 +60,7 @@ describe('Given the Aave Protocol v3', () => {
       expect(result.value).toMatchSnapshot({
         availableBorrowsBase: expect.any(String),
         currentLiquidationThreshold: expect.any(String),
-        eModeEnabled: expect.any(Boolean),
         healthFactor: expect.any(String),
-        isInIsolationMode: expect.any(Boolean),
         ltv: expect.any(String),
         netAPY: expect.any(String),
         netWorth: expect.any(String),

packages/graphql/package.json

@@ -40,7 +40,8 @@
     "gql:download:staging": "gql-tada generate schema 'https://api.v3.staging.aave.com/graphql' --output './schema.graphql'",
     "gql:download:local": "gql-tada generate schema 'http://localhost:3011/graphql' --output './schema.graphql'",
     "gql:generate": "gql-tada generate output",
-    "gql:turbo": "gql-tada turbo"
+    "gql:turbo": "gql-tada turbo",
+    "prebuild": "pnpm run gql:turbo"
   },
   "dependencies": {
     "@aave/types": "workspace:*",