feat: endpoint for active user (#17)

Author: norugpull

apps/indexer/src/app/routes/_chain/routes.ts

@@ -9,9 +9,11 @@ import { TTokenSelected, tTokensSelectors } from '../../../database/selectors';
 import {
   fetchPoolList,
   fetchPoolReserves,
+  fetchUserReserves,
   selectPoolById,
 } from '../../../libs/loaders/money-market';
 import { paginationResponse, paginationSchema } from '../../../libs/pagination';
+import { transformUserReservesData } from '../../../libs/utils/user-reserves';
 
 interface ReserveDataHumanized {
   originalId: number;
@@ -262,4 +264,88 @@ export default async function (fastify: FastifyInstance) {
       // };
     },
   );
+
+  fastify.withTypeProvider<ZodTypeProvider>().get(
+    '/money-market/:pool/user/:address/lendings',
+    {
+      schema: {
+        querystring: paginationSchema,
+        params: z.object({
+          pool: z.string(),
+          address: z.string(),
+        }),
+      },
+      config: {
+        cache: true,
+      },
+    },
+    async (
+      req: FastifyRequest<{ Params: { pool: string; address: string } }>,
+      reply,
+    ) => {
+      const pools = await fetchPoolList(req.chain.chainId);
+      const pool = selectPoolById(req.params.pool, pools);
+
+      if (!pool) return reply.notFound('Pool not found');
+
+      const userReservesRaw = await fetchUserReserves(
+        req.chain.chainId,
+        pool,
+        req.params.address,
+      );
+
+      const activePositions = userReservesRaw.filter(
+        (r) => r.scaledATokenBalance > 0n,
+      );
+
+      return transformUserReservesData({
+        chainId: req.chain.chainId,
+        userAddress: req.params.address,
+        pool,
+        reserves: activePositions,
+      });
+    },
+  );
+
+  fastify.withTypeProvider<ZodTypeProvider>().get(
+    '/money-market/:pool/user/:address/borrowings',
+    {
+      schema: {
+        querystring: paginationSchema,
+        params: z.object({
+          pool: z.string(),
+          address: z.string(),
+        }),
+      },
+      config: {
+        cache: true,
+      },
+    },
+    async (
+      req: FastifyRequest<{ Params: { pool: string; address: string } }>,
+      reply,
+    ) => {
+      const pools = await fetchPoolList(req.chain.chainId);
+      const pool = selectPoolById(req.params.pool, pools);
+
+      if (!pool) return reply.notFound('Pool not found');
+
+      const userReservesRaw = await fetchUserReserves(
+        req.chain.chainId,
+        pool,
+        req.params.address,
+      );
+
+      const activeBorrows = userReservesRaw.filter(
+        (r) => r.scaledVariableDebt > 0n || r.principalStableDebt > 0n,
+      );
+
+      return transformUserReservesData({
+        chainId: req.chain.chainId,
+        userAddress: req.params.address,
+        pool,
+        reserves: activeBorrows,
+      });
+    },
+  );
 }

apps/indexer/src/libs/loaders/money-market.ts

@@ -353,7 +353,7 @@ const uiPoolDataProviderAbi = [
   },
 ] as const;
 
-type PoolDefinition = {
+export type PoolDefinition = {
   id: string | 'default';
   name: string;
   logoURI: string;
@@ -407,3 +407,21 @@ export async function fetchPoolReserves(
     args: [pool.poolAddressesProvider],
   });
 }
+
+export async function fetchUserReserves(
+  chainId: ChainSelector,
+  pool: PoolDefinition,
+  user: string,
+) {
+  const chain = chains.get(chainId);
+  if (!chain) {
+    throw new Error(`Unsupported chain: ${chainId}`);
+  }
+
+  return chain.rpc.readContract({
+    address: pool.uiPoolDataProvider,
+    abi: uiPoolDataProviderAbi,
+    functionName: 'getUserReservesData',
+    args: [pool.poolAddressesProvider, user as Address],
+  });
+}

apps/indexer/src/libs/utils/user-reserves.ts

@@ -0,0 +1,57 @@
+import { areAddressesEqual } from '@sovryn/slayer-shared';
+import { and, eq, inArray } from 'drizzle-orm';
+import { client } from '../../database/client';
+import { tTokens } from '../../database/schema';
+import { tTokensSelectors } from '../../database/selectors';
+import { PoolDefinition } from '../loaders/money-market';
+
+export async function transformUserReservesData({
+  chainId,
+  userAddress,
+  pool,
+  reserves,
+}: {
+  chainId: number;
+  userAddress: string;
+  pool: PoolDefinition;
+  reserves: Array<{
+    underlyingAsset: string;
+    scaledATokenBalance: bigint;
+    usageAsCollateralEnabledOnUser: boolean;
+    stableBorrowRate: bigint;
+    scaledVariableDebt: bigint;
+    principalStableDebt: bigint;
+    stableBorrowLastUpdateTimestamp: bigint;
+  }>;
+}) {
+  if (!reserves.length) {
+    return { data: [], count: 0 };
+  }
+
+  const tokens = await client.query.tTokens.findMany({
+    columns: tTokensSelectors.columns,
+    where: and(
+      eq(tTokens.chainId, chainId),
+      inArray(
+        tTokens.address,
+        reserves.map((i) => i.underlyingAsset.toLowerCase()),
+      ),
+    ),
+  });
+
+  const data = reserves.map((pos) => ({
+    id: `${chainId}-${pos.underlyingAsset}-${pool.address}-${userAddress}`.toLowerCase(),
+    user: userAddress,
+    pool,
+    token: tokens.find((t) =>
+      areAddressesEqual(t.address, pos.underlyingAsset),
+    ),
+    scaledVariableDebt: pos?.scaledVariableDebt.toString(),
+    principalStableDebt: pos?.principalStableDebt.toString(),
+    stableBorrowRate: pos?.stableBorrowRate.toString(),
+    stableBorrowLastUpdateTimestamp: pos.stableBorrowLastUpdateTimestamp,
+    usageAsCollateralEnabledOnUser: pos.usageAsCollateralEnabledOnUser,
+  }));
+
+  return { data, count: data.length };
+}