impermax-sdk 1.0.1 → 1.0.2

package/lib/esm/subgraph/SolidexHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class SolidexHelper {
+    constructor(subgraph) {
+        this.subgraph = subgraph;
+    }
+    cleanCache() {
+        this.solidexLPDetails = null;
+    }
+    initializeSolidexLPDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch("https://api.solidexfinance.com/api/getLPDetails?v=fantom");
+                if (response.status != 200)
+                    return {};
+                const data = yield response.json();
+                if (!data || !data.success)
+                    return {};
+                const solidexLPDetails = {};
+                for (const pool of data.data.poolDetailsAll) {
+                    if (!pool.solidexTVL)
+                        continue;
+                    solidexLPDetails[pool.poolAddress.toLowerCase()] = [
+                        {
+                            APR: pool.solidexTVL.realsolidAPR / 100,
+                            symbol: "SOLID",
+                        },
+                        {
+                            APR: pool.solidexTVL.realsexAPR / 100,
+                            symbol: "SEX",
+                        },
+                    ];
+                }
+                return solidexLPDetails;
+            }
+            catch (e) {
+                return {};
+            }
+        });
+    }
+    getSolidexLPDetails() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.solidexLPDetails)
+                this.solidexLPDetails = this.initializeSolidexLPDetails();
+            return this.solidexLPDetails;
+        });
+    }
+}
+exports.default = SolidexHelper;

package/lib/esm/subgraph/index.d.ts

@@ -0,0 +1,73 @@
+import { LendingPoolData, TvlData, UserData, XimxData } from "../impermax-router/interfaces";
+import * as initializer from "./initializer";
+import LendingPool from "./LendingPool";
+import PriceHelper from "./PriceHelper";
+import SolidexHelper from "./SolidexHelper";
+import Account from "./Account";
+import { Address, Factory, FactoryIndex, LendingPoolIndex, Networks } from '../config/types';
+export interface SubgraphCfg {
+    network: Networks;
+    chainId: number;
+    whitelistedPairs?: FactoryIndex<Address[]>;
+}
+export default class Subgraph {
+    network: Networks;
+    chainId: number;
+    whitelistedPairs?: FactoryIndex<Address[]>;
+    lendingPools: LendingPoolIndex<LendingPool>;
+    accounts: {
+        [key in Address]?: Account;
+    };
+    priceHelper: PriceHelper;
+    solidexHelper: SolidexHelper;
+    lendingPoolsData: Promise<LendingPoolIndex<LendingPoolData>>;
+    usersData: {
+        [key in Address]?: Promise<FactoryIndex<UserData>>;
+    };
+    tvlData: Promise<TvlData>;
+    ximxData: Promise<XimxData>;
+    constructor(cfg: SubgraphCfg);
+    cleanCache(): void;
+    getLendingPool(factory: Factory, pairAddress: Address): Promise<LendingPool>;
+    getAccount(account: Address): Account;
+    /**
+     * TODO
+     * Potrei organizzare in:
+     * - lendingPoolData
+     * - usersData
+     * - tvlData
+     * - ximxData
+     */
+    apolloFetcher: typeof initializer.apolloFetcher;
+    fetchLendingPools: typeof initializer.fetchLendingPools;
+    fetchLendingPoolsPast: typeof initializer.fetchLendingPoolsPast;
+    fetchPastVolume: typeof initializer.fetchPastVolume;
+    fetchCurrentVolumeAndReserves: typeof initializer.fetchCurrentVolumeAndReserves;
+    fetchImpermaxChefRewardRates: typeof initializer.fetchImpermaxChefRewardRates;
+    fetchUniswapAPR: typeof initializer.fetchUniswapAPR;
+    fetchBlockByTimestamp: typeof initializer.fetchBlockByTimestamp;
+    initializeLendingPoolsData: typeof initializer.initializeLendingPoolsData;
+    getLendingPoolsData: typeof initializer.getLendingPoolsData;
+    getLendingPoolData: typeof initializer.getLendingPoolData;
+    initializeTvlData: typeof initializer.initializeTvlData;
+    getTvlData: typeof initializer.getTvlData;
+    fetchUserData: typeof initializer.fetchUserData;
+    initializeUserData: typeof initializer.initializeUserData;
+    getUserData: typeof initializer.getUserData;
+    initializeXimxData: typeof initializer.initializeXimxData;
+    getXimxData: typeof initializer.getXimxData;
+    /**
+     * DATA GETTERS
+     */
+    getPairList(): Promise<any[]>;
+    private getPairData;
+    getPairListWithData(pairList: {
+        pairAddress: string;
+        factory: Factory;
+    }[]): Promise<any[]>;
+    getCrossChainTVL(): Promise<number>;
+    getTotalValueLocked(): Promise<number>;
+    getTotalValueSupplied(): Promise<number>;
+    getTotalValueBorrowed(): Promise<number>;
+    getXIMXAPY(): Promise<number>;
+}

package/lib/esm/subgraph/index.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const initializer = __importStar(require("./initializer"));
+const PriceHelper_1 = __importDefault(require("./PriceHelper"));
+const SolidexHelper_1 = __importDefault(require("./SolidexHelper"));
+const Account_1 = __importDefault(require("./Account"));
+class Subgraph {
+    constructor(cfg) {
+        /**
+         * TODO
+         * Potrei organizzare in:
+         * - lendingPoolData
+         * - usersData
+         * - tvlData
+         * - ximxData
+         */
+        // Fetchers
+        this.apolloFetcher = initializer.apolloFetcher;
+        this.fetchLendingPools = initializer.fetchLendingPools;
+        this.fetchLendingPoolsPast = initializer.fetchLendingPoolsPast;
+        this.fetchPastVolume = initializer.fetchPastVolume;
+        this.fetchCurrentVolumeAndReserves = initializer.fetchCurrentVolumeAndReserves;
+        this.fetchImpermaxChefRewardRates = initializer.fetchImpermaxChefRewardRates;
+        this.fetchUniswapAPR = initializer.fetchUniswapAPR;
+        this.fetchBlockByTimestamp = initializer.fetchBlockByTimestamp;
+        this.initializeLendingPoolsData = initializer.initializeLendingPoolsData;
+        this.getLendingPoolsData = initializer.getLendingPoolsData;
+        this.getLendingPoolData = initializer.getLendingPoolData;
+        this.initializeTvlData = initializer.initializeTvlData;
+        this.getTvlData = initializer.getTvlData;
+        this.fetchUserData = initializer.fetchUserData;
+        this.initializeUserData = initializer.initializeUserData;
+        this.getUserData = initializer.getUserData;
+        this.initializeXimxData = initializer.initializeXimxData;
+        this.getXimxData = initializer.getXimxData;
+        this.network = cfg.network;
+        this.chainId = cfg.chainId;
+        this.whitelistedPairs = cfg.whitelistedPairs;
+        this.priceHelper = new PriceHelper_1.default(this);
+        this.solidexHelper = new SolidexHelper_1.default(this);
+        this.accounts = {};
+        this.usersData = {};
+    }
+    cleanCache() {
+        this.lendingPoolsData = null;
+        this.usersData = {};
+        this.tvlData = null;
+        this.ximxData = null;
+        this.priceHelper.cleanCache();
+        this.solidexHelper.cleanCache();
+    }
+    getLendingPool(factory, pairAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getLendingPoolsData(); // make sure that lending pools are initialized
+            return this.lendingPools[factory][pairAddress];
+        });
+    }
+    getAccount(account) {
+        if (!this.accounts[account])
+            this.accounts[account] = new Account_1.default(this, account);
+        return this.accounts[account];
+    }
+    /**
+     * DATA GETTERS
+     */
+    // Pair List
+    /*async getPairListOld() : Promise<FactoryIndex<Address[]>> {
+      const result: FactoryIndex<Address[]> = {};
+      const lendingPoolData = await this.getLendingPoolsData();
+      for (const factory of Object.keys(lendingPoolData) as Factory[]) {
+        result[factory] = Object.keys(lendingPoolData[factory]);
+      }
+      return result;
+    }
+      async getPairListWithData() {
+      const pairList = await this.getPairList();
+      if (!pairList) return null;
+      const requests = [];
+      for (const factory of Object.keys(pairList) as Factory[]) {
+        for (const pairAddress of pairList[factory]) {
+          requests.push(this.getPairData(factory, pairAddress));
+        }
+      }
+      console.log("length", requests.length)
+      return Promise.all(requests);
+    }*/
+    getPairList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = [];
+            const lendingPoolData = yield this.getLendingPoolsData();
+            for (const factory of Object.keys(lendingPoolData)) {
+                for (const pairAddress of Object.keys(lendingPoolData[factory])) {
+                    result.push({ pairAddress, factory });
+                }
+            }
+            return result;
+        });
+    }
+    getPairData(factory, pairAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPool = yield this.getLendingPool(factory, pairAddress);
+            const totalBorrowsUSD = yield lendingPool.getTotalBorrowsUSD();
+            return { pairAddress, factory, totalBorrowsUSD };
+        });
+    }
+    getPairListWithData(pairList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requests = [];
+            for (const pair of pairList) {
+                requests.push(this.getPairData(pair.factory, pair.pairAddress));
+            }
+            return Promise.all(requests);
+        });
+    }
+    // TVL Data
+    getCrossChainTVL() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tvlData = yield this.getTvlData();
+            return tvlData.crossChainTVLUSD;
+        });
+    }
+    getTotalValueLocked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tvlData = yield this.getTvlData();
+            return tvlData.totalBalanceUSD;
+        });
+    }
+    getTotalValueSupplied() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tvlData = yield this.getTvlData();
+            return tvlData.totalSupplyUSD;
+        });
+    }
+    getTotalValueBorrowed() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tvlData = yield this.getTvlData();
+            return tvlData.totalBorrowsUSD;
+        });
+    }
+    // IMX Staking
+    getXIMXAPY() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ximxData = yield this.getXimxData();
+            if (!ximxData)
+                return 0;
+            return Math.pow(1 + parseFloat(ximxData.dailyAPR), 365) - 1;
+        });
+    }
+}
+exports.default = Subgraph;

package/lib/esm/subgraph/initializer.d.ts

@@ -0,0 +1,34 @@
+import { LendingPoolData, TvlData, UserData, CollateralPosition, SupplyPosition, BorrowPosition, XimxData } from "../impermax-router/interfaces";
+import Subgraph from "./index";
+import { DocumentNode } from "graphql";
+import { Address, AddressIndex, Amms, Factory, FactoryIndex, LendingPoolIndex } from '../config/types';
+export declare function apolloFetcher(subgraphUrl: string, query: DocumentNode): Promise<import("apollo-client").ApolloQueryResult<any>>;
+export declare function fetchBlockByTimestamp(this: Subgraph, timestamp: number): Promise<number>;
+export declare function fetchLendingPools(this: Subgraph): Promise<FactoryIndex<LendingPoolData[]>>;
+export declare function fetchLendingPoolsPast(this: Subgraph, seconds: number): Promise<FactoryIndex<any[]>>;
+export declare function fetchImpermaxChefRewardRates(this: Subgraph): Promise<AddressIndex<Array<{
+    rewardToken: Address;
+    rewardRate: number;
+}>>>;
+export declare function fetchPastVolume(this: Subgraph, amm: Amms, lendingPools: LendingPoolData[], seconds: number): Promise<AddressIndex<number>>;
+export declare function fetchCurrentVolumeAndReserves(this: Subgraph, amm: Amms, lendingPools: LendingPoolData[]): Promise<{
+    currentVolume: AddressIndex<number>;
+    currentReserve: AddressIndex<number>;
+}>;
+export declare function fetchUniswapAPR(this: Subgraph, lendingPoolsByAmm: {
+    [key in Amms]?: LendingPoolData[];
+}, seconds?: number): Promise<AddressIndex<number>>;
+export declare function initializeLendingPoolsData(this: Subgraph): Promise<LendingPoolIndex<LendingPoolData>>;
+export declare function getLendingPoolsData(this: Subgraph): Promise<LendingPoolIndex<LendingPoolData>>;
+export declare function getLendingPoolData(this: Subgraph, factory: Factory, uniswapV2PairAddress: Address): Promise<LendingPoolData>;
+export declare function initializeTvlData(this: Subgraph): Promise<TvlData>;
+export declare function getTvlData(this: Subgraph): Promise<TvlData>;
+export declare function fetchUserData(this: Subgraph, account: Address): Promise<FactoryIndex<{
+    collateralPositions: CollateralPosition[];
+    supplyPositions: SupplyPosition[];
+    borrowPositions: BorrowPosition[];
+}>>;
+export declare function initializeUserData(this: Subgraph, account: Address): Promise<FactoryIndex<UserData>>;
+export declare function getUserData(this: Subgraph, account: Address): Promise<FactoryIndex<UserData>>;
+export declare function initializeXimxData(this: Subgraph): Promise<XimxData>;
+export declare function getXimxData(this: Subgraph): Promise<XimxData>;