@1delta/margin-fetcher 0.0.1

package/test/mainPrices.test.ts

@@ -0,0 +1,35 @@
+import { describe, it } from 'vitest'
+import { fetchMainPrices } from "../src"
+import { Chain } from "@1delta/asset-registry"
+import { getEvmClient } from '@1delta/providers'
+
+
+describe('find prices', () => {
+  it('should return prices for valid tokens', async () => {
+    const mainPrices = await fetchMainPrices([
+      Chain.MANTLE,
+      Chain.BNB_SMART_CHAIN_MAINNET,
+      Chain.OP_MAINNET,
+      Chain.POLYGON_MAINNET,
+      Chain.HEMI_NETWORK,
+      Chain.ARBITRUM_ONE,
+      Chain.BASE
+    ], getEvmClient)
+    prettyPrint(mainPrices)
+
+  })
+}, { timeout: 10000 })
+
+
+function prettyPrint(obj: any) {
+  for (const key in obj) {
+    const value = obj[key]
+    const keyStr = `\x1b[1m\x1b[36m${key}:\x1b[0m` // bold cyan
+    if (typeof value === 'object' && value !== null) {
+      console.log(`${keyStr}`)
+      console.dir(value, { depth: null, colors: true })
+    } else {
+      console.log(`${keyStr} ${value}`)
+    }
+  }
+}

package/test/userdata.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import {
+  getLenderUserDataResult,
+  convertLenderUserDataResult,
+} from "../src/lending/user-data/fetchUserData";
+import {
+  fetchDefillamaData,
+  fetchGeneralYields,
+  getLenderPublicData,
+} from "../src";
+import { multicallRetry, getEvmClient } from "@1delta/providers";
+import { Chain, Lender } from "@1delta/asset-registry";
+import { LenderUserQuery } from "../src/lending/user-data/types";
+import { getLendersForChain } from "../src/utils";
+
+const TEST_ADDRESS = "0x91ae002a960e63Ccb0E5bDE83A8C13E51e1cB91A";
+let prices, yields;
+
+async function getUserData(chainId: Chain, lenders: Lender[]) {
+  const _lenders = getLendersForChain(chainId);
+  const publicData = await getLenderPublicData(
+    chainId,
+    _lenders as any,
+    prices as any,
+    yields as any,
+    multicallRetry
+  );
+
+  // Define user queries
+  const queries: LenderUserQuery[] = lenders.map((lender) => ({
+    lender,
+    account: TEST_ADDRESS,
+  }));
+
+  // Fetch raw user data
+  const rawUserData = await getLenderUserDataResult(
+    chainId,
+    queries,
+    getEvmClient
+  );
+
+  // Convert raw data to structured format
+  const userData = convertLenderUserDataResult(
+    chainId,
+    queries,
+    rawUserData,
+    prices as any,
+    prices as any,
+    publicData
+  );
+
+  return { userData, rawUserData, publicData, queries };
+}
+
+describe(
+  "user data fetching",
+  () => {
+    beforeAll(async () => {
+      [prices, yields] = await Promise.all([
+        fetchDefillamaData(),
+        fetchGeneralYields(),
+      ]);
+    }, 30000);
+
+    it(
+      "should fetch user data for AAVE V3 on Base",
+      async () => {
+        try {
+          const { userData } = await getUserData(Chain.BASE, [Lender.AAVE_V3]);
+
+          console.log("AAVE V3 Base user data:", userData);
+
+          // Basic validation
+          expect(userData).toBeDefined();
+          expect(typeof userData).toBe("object");
+        } catch (error) {
+          console.log("Error fetching AAVE V3 Base data:", error);
+        }
+      },
+      { timeout: 30000 }
+    );
+
+    it(
+      "should fetch user data for multiple protocols on Arbitrum",
+      async () => {
+        try {
+          const { userData, queries } = await getUserData(
+            Chain.ARBITRUM_ONE,
+            [Lender.AAVE_V3, Lender.COMPOUND_V3_USDC, Lender.COMPOUND_V3_USDC_E]
+          );
+
+          console.log("Arbitrum multi-protocol user data:", userData);
+
+          expect(userData).toBeDefined();
+          expect(typeof userData).toBe("object");
+
+          // Check that we get data for each queried protocol
+          queries.forEach((query) => {
+            if (userData[query.lender]) {
+              console.log(`Found data for ${query.lender} on Arbitrum`);
+              expect(userData[query.lender]).toBeDefined();
+            }
+          });
+        } catch (error) {
+          console.log("Error fetching Arbitrum multi-protocol data:", error);
+        }
+      },
+      { timeout: 30000 }
+    );
+
+    it(
+      "should fetch user data across multiple chains",
+      async () => {
+        const testChains = [
+          Chain.ETHEREUM_MAINNET,
+          Chain.POLYGON_MAINNET,
+          Chain.BASE,
+        ];
+
+        try {
+          for (const chainId of testChains) {
+            const lenders = getLendersForChain(chainId);
+            if (lenders.length === 0) {
+              console.log(`No lenders available on ${chainId}`);
+              continue;
+            }
+
+            const publicData = await getLenderPublicData(
+              chainId,
+              lenders as any,
+              prices as any,
+              yields as any,
+              multicallRetry
+            );
+
+            const firstLender = lenders[0] as Lender;
+            const queries: LenderUserQuery[] = [
+              { lender: firstLender, account: TEST_ADDRESS }, // test first lender
+            ];
+
+            const rawUserData = await getLenderUserDataResult(
+              chainId,
+              queries,
+              getEvmClient
+            );
+
+            const userData = convertLenderUserDataResult(
+              chainId,
+              queries,
+              rawUserData,
+              prices as any,
+              prices as any,
+              publicData
+            );
+
+            console.log(`${chainId} - ${firstLender} user data:`, userData);
+
+            expect(userData).toBeDefined();
+            expect(typeof userData).toBe("object");
+          }
+        } catch (error) {
+          console.log("Error in multi-chain test:", error);
+        }
+      },
+      { timeout: 60000 }
+    );
+
+    it(
+      "should fetch user data for Init protocol on Mantle",
+      async () => {
+        const chainId = Chain.MANTLE;
+
+        try {
+          const { userData } = await getUserData(
+            Chain.MANTLE,
+            [Lender.INIT]
+          );
+
+          console.log("Init protocol Mantle user data:", userData);
+
+          expect(userData).toBeDefined();
+          expect(typeof userData).toBe("object");
+        } catch (error) {
+          console.log("Error fetching Init protocol data:", error);
+        }
+      },
+      { timeout: 30000 }
+    );
+
+    it("should handle empty queries", async () => {
+      const { userData } = await getUserData(Chain.BASE, []);
+
+      expect(userData).toBeDefined();
+      expect(Object.keys(userData)).toHaveLength(0);
+    });
+
+
+  },
+  { timeout: 90000 }
+);

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext", // Ensure ESM (ES Modules) output
+    "target": "ESNext", // Output code that targets the latest ES features
+    "moduleResolution": "node", // Use Node.js module resolution
+    "esModuleInterop": true, // For compatibility with commonjs
+    "outDir": "dist", // Specify output directory
+    "rootDir": "src", // Specify output directory
+    "declaration": true, // Generate .d.ts files
+    "declarationMap": true, // Generate declaration map files
+    "allowJs": true, // Allow JavaScript files to be included
+    "resolveJsonModule": true, // Allow importing JSON files
+    "skipLibCheck": true, // Skip type checking of all declaration files
+    "strict": true, // Enable strict type checking
+    "isolatedModules": true // Allow isolated module builds
+  },
+  "include": [
+    "src/**/*",
+    "src/**/**/*",
+    "src/**/**/**/*",
+    "src/*"
+  ], // Include all the TypeScript files in src/
+  "exclude": [
+    "node_modules",
+    "dist"
+  ] // Exclude node_modules and dist from being compiled
+}