test: check userPositions match (totalCollateral, totalSupplied, totalDebt, netBalance)

.changeset/mighty-phones-raise.md

@@ -0,0 +1,2 @@
+---
+---

packages/client/src/testing.ts

@@ -66,6 +66,9 @@ export const ETHEREUM_WSTETH_ADDRESS = evmAddress(
 export const ETHEREUM_1INCH_ADDRESS = evmAddress(
   '0x111111111117dC0aa78b770fA6A738034120C302',
 );
+export const ETHEREUM_AAVE_ADDRESS = evmAddress(
+  '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
+);
 
 // Spoke addresses and ids
 export const ETHEREUM_SPOKE_CORE_ADDRESS = evmAddress(
@@ -115,7 +118,7 @@ export const client = AaveClient.create({
   environment,
 });
 
-const devnetChain = await chain(client, { chainId: ETHEREUM_FORK_ID })
+export const devnetChain = await chain(client, { chainId: ETHEREUM_FORK_ID })
   .map(nonNullable)
   .map(toViemChain)
   .match(

packages/spec/borrow/business.spec.ts

@@ -23,18 +23,13 @@ describe('Borrowing Assets on Aave V4', () => {
     beforeAll(async () => {
       const amountToSupply = bigDecimal('100');
 
-      const setup = await fundErc20Address(evmAddress(user.account.address), {
-        address: ETHEREUM_USDC_ADDRESS,
+      const setup = await findReserveAndSupply(client, user, {
+        token: ETHEREUM_USDC_ADDRESS,
+        spoke: ETHEREUM_SPOKE_CORE_ID,
         amount: amountToSupply,
-        decimals: 6,
-      }).andThen(() =>
-        findReserveAndSupply(client, user, {
-          token: ETHEREUM_USDC_ADDRESS,
-          spoke: ETHEREUM_SPOKE_CORE_ID,
-          amount: amountToSupply,
-          asCollateral: true,
-        }),
-      );
+        asCollateral: true,
+        autoFund: true,
+      });
 
       assertOk(setup);
     });

packages/spec/borrow/multipleBorrows.spec.ts

@@ -5,7 +5,6 @@ import {
   createNewWallet,
   ETHEREUM_SPOKE_CORE_ID,
   ETHEREUM_USDC_ADDRESS,
-  fundErc20Address,
 } from '@aave/client/testing';
 import { sendWith } from '@aave/client/viem';
 import { beforeAll, describe, expect, it } from 'vitest';
@@ -21,18 +20,13 @@ describe('Borrowing from Multiple Reserves on Aave V4', () => {
       beforeAll(async () => {
         const amountToSupply = bigDecimal('100');
 
-        const setup = await fundErc20Address(evmAddress(user.account.address), {
-          address: ETHEREUM_USDC_ADDRESS,
+        const setup = await findReserveAndSupply(client, user, {
+          token: ETHEREUM_USDC_ADDRESS,
+          spoke: ETHEREUM_SPOKE_CORE_ID,
           amount: amountToSupply,
-          decimals: 6,
-        }).andThen(() =>
-          findReserveAndSupply(client, user, {
-            token: ETHEREUM_USDC_ADDRESS,
-            spoke: ETHEREUM_SPOKE_CORE_ID,
-            amount: amountToSupply,
-            asCollateral: true,
-          }),
-        );
+          asCollateral: true,
+          autoFund: true,
+        });
 
         assertOk(setup);
       }, 120_000);

packages/spec/helpers/supplyBorrow.ts

@@ -72,23 +72,39 @@ export function findReserveAndSupply(
     amount,
     spoke,
     asCollateral,
+    autoFund,
   }: {
     token: EvmAddress;
     amount: BigDecimal;
     spoke?: SpokeId;
     asCollateral?: boolean;
+    autoFund?: boolean;
   },
 ): ResultAsync<Reserve, Error> {
   return findReservesToSupply(client, user, {
     token: token,
     spoke: spoke,
     asCollateral: asCollateral,
   }).andThen((reserves) =>
-    supplyToReserve(client, user, {
-      reserve: reserves[0].id,
-      amount: { erc20: { value: amount } },
-      sender: evmAddress(user.account.address),
-    }).map(() => reserves[0]),
+    autoFund
+      ? fundErc20Address(evmAddress(user.account.address), {
+          address: token,
+          amount: amount,
+          decimals: reserves[0]!.asset.underlying.info.decimals,
+        }).andThen(() =>
+          supplyToReserve(client, user, {
+            reserve: reserves[0]!.id,
+            amount: { erc20: { value: amount } },
+            sender: evmAddress(user.account.address),
+            enableCollateral: asCollateral ?? true,
+          }).map(() => reserves[0]),
+        )
+      : supplyToReserve(client, user, {
+          reserve: reserves[0].id,
+          amount: { erc20: { value: amount } },
+          sender: evmAddress(user.account.address),
+          enableCollateral: asCollateral ?? true,
+        }).map(() => reserves[0]),
   );
 }
 
@@ -141,6 +157,33 @@ export function supplyAndBorrow(
   );
 }
 
+export function borrowFromRandomReserve(
+  client: AaveClient,
+  user: WalletClient<Transport, Chain, Account>,
+  params: {
+    spoke?: SpokeId;
+    token?: EvmAddress;
+    ratioToBorrow?: number;
+  },
+): ResultAsync<Reserve, Error> {
+  return findReservesToBorrow(client, user, {
+    spoke: params.spoke,
+    token: params.token,
+  }).andThen((reserves) => {
+    return borrowFromReserve(client, user, {
+      reserve: reserves[0].id,
+      amount: {
+        erc20: {
+          value: reserves[0].userState!.borrowable.amount.value.times(
+            params.ratioToBorrow ?? 0.1,
+          ),
+        },
+      },
+      sender: evmAddress(user.account.address),
+    }).map(() => reserves[0]);
+  });
+}
+
 export function supplyAndBorrowNativeToken(
   client: AaveClient,
   user: WalletClient<Transport, Chain, Account>,

packages/spec/positions/business.spec.ts

@@ -40,18 +40,13 @@ describe('Health Factor Scenarios on Aave V4', () => {
       beforeAll(async () => {
         const amountToSupply = bigDecimal('100');
 
-        const setup = await fundErc20Address(evmAddress(user.account.address), {
-          address: ETHEREUM_USDC_ADDRESS,
+        const setup = await findReserveAndSupply(client, user, {
+          token: ETHEREUM_USDC_ADDRESS,
+          spoke: ETHEREUM_SPOKE_CORE_ID,
+          asCollateral: true,
           amount: amountToSupply,
-          decimals: 6,
-        }).andThen(() =>
-          findReserveAndSupply(client, user, {
-            token: ETHEREUM_USDC_ADDRESS,
-            spoke: ETHEREUM_SPOKE_CORE_ID,
-            asCollateral: true,
-            amount: amountToSupply,
-          }),
-        );
+          autoFund: true,
+        });
 
         assertOk(setup);
       });

packages/spec/positions/helper.ts

@@ -16,24 +16,26 @@ import {
   userSupplies,
 } from '@aave/client/actions';
 import {
+  ETHEREUM_AAVE_ADDRESS,
   ETHEREUM_FORK_ID,
   ETHEREUM_GHO_ADDRESS,
   ETHEREUM_SPOKE_CORE_ID,
   ETHEREUM_SPOKE_ETHENA_ID,
+  ETHEREUM_USDC_ADDRESS,
   ETHEREUM_WETH_ADDRESS,
-  ETHEREUM_WSTETH_ADDRESS,
   fundErc20Address,
 } from '@aave/client/testing';
 import { sendWith } from '@aave/client/viem';
 import type { Account, Chain, Transport, WalletClient } from 'viem';
+
 import {
   findReservesToBorrow,
   findReservesToSupply,
 } from '../helpers/reserves';
 import {
+  borrowFromRandomReserve,
   borrowFromReserve,
   findReserveAndSupply,
-  supplyAndBorrowNativeToken,
   supplyToReserve,
 } from '../helpers/supplyBorrow';
 import {
@@ -203,41 +205,6 @@ export const recreateUserActivities = async (
   }
 };
 
-export const recreateUserSummary = async (
-  client: AaveClient,
-  user: WalletClient<Transport, Chain, Account>,
-) => {
-  const setup = await fundErc20Address(evmAddress(user.account.address), {
-    address: ETHEREUM_WETH_ADDRESS,
-    amount: bigDecimal('0.5'),
-  })
-    .andThen(() =>
-      fundErc20Address(evmAddress(user.account.address), {
-        address: ETHEREUM_WSTETH_ADDRESS,
-        amount: bigDecimal('0.5'),
-      }),
-    )
-    .andThen(() =>
-      fundErc20Address(evmAddress(user.account.address), {
-        address: ETHEREUM_GHO_ADDRESS,
-        amount: bigDecimal('100'),
-      }),
-    )
-    .andThen(() =>
-      findReserveAndSupply(client, user, {
-        token: ETHEREUM_GHO_ADDRESS,
-        amount: bigDecimal('100'),
-      }),
-    )
-    .andThen(() =>
-      supplyAndBorrowNativeToken(client, user, {
-        spoke: ETHEREUM_SPOKE_CORE_ID,
-        ratioToBorrow: 0.4,
-      }),
-    );
-  assertOk(setup);
-};
-
 export const recreateUserBorrows = async (
   client: AaveClient,
   user: WalletClient<Transport, Chain, Account>,
@@ -423,3 +390,86 @@ export const recreateUserPositions = async (
     assertOk(resultEmodeSpoke);
   }
 };
+
+export const recreateUserPositionInOneSpoke = async (
+  client: AaveClient,
+  user: WalletClient<Transport, Chain, Account>,
+) => {
+  // Check the user has at least one
+  const supplies = await userSupplies(client, {
+    query: {
+      userSpoke: {
+        spoke: ETHEREUM_SPOKE_CORE_ID,
+        user: evmAddress(user.account.address),
+      },
+    },
+  });
+  assertOk(supplies);
+  const userInfo = await userPositions(client, {
+    user: evmAddress(user.account.address),
+    filter: {
+      chainIds: [ETHEREUM_FORK_ID],
+    },
+  });
+  assertOk(userInfo);
+
+  // Create a position in the spoke
+  if (
+    supplies.value.length < 3 ||
+    // Add supply if health factor is less than 4
+    userInfo.value[0]!.healthFactor.current!.lt(4)
+  ) {
+    const supplyGHOCollateral = await findReserveAndSupply(client, user, {
+      spoke: ETHEREUM_SPOKE_CORE_ID,
+      token: ETHEREUM_GHO_ADDRESS,
+      asCollateral: true,
+      amount: bigDecimal('100'),
+      autoFund: true,
+    });
+    assertOk(supplyGHOCollateral);
+
+    const supplyUSDCDNoCollateral = await findReserveAndSupply(client, user, {
+      spoke: ETHEREUM_SPOKE_CORE_ID,
+      token: ETHEREUM_USDC_ADDRESS,
+      asCollateral: false,
+      amount: bigDecimal('100'),
+      autoFund: true,
+    });
+    assertOk(supplyUSDCDNoCollateral);
+
+    const supplyWETHCollateral = await findReserveAndSupply(client, user, {
+      spoke: ETHEREUM_SPOKE_CORE_ID,
+      token: ETHEREUM_AAVE_ADDRESS,
+      asCollateral: true,
+      amount: bigDecimal('0.5'),
+      autoFund: true,
+    });
+    assertOk(supplyWETHCollateral);
+  }
+
+  const borrows = await userBorrows(client, {
+    query: {
+      userSpoke: {
+        spoke: ETHEREUM_SPOKE_CORE_ID,
+        user: evmAddress(user.account.address),
+      },
+    },
+  });
+  assertOk(borrows);
+
+  if (borrows.value.length < 2) {
+    const borrowAAVE = await borrowFromRandomReserve(client, user, {
+      spoke: ETHEREUM_SPOKE_CORE_ID,
+      token: ETHEREUM_AAVE_ADDRESS,
+      ratioToBorrow: 0.1,
+    });
+    assertOk(borrowAAVE);
+
+    const borrowWETH = await borrowFromRandomReserve(client, user, {
+      spoke: ETHEREUM_SPOKE_CORE_ID,
+      token: ETHEREUM_WETH_ADDRESS,
+      ratioToBorrow: 0.1,
+    });
+    assertOk(borrowWETH);
+  }
+};